diff --git a/.circleci/config.yml b/.circleci/config.yml
index d11712c..22c6f71 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,33 +1,96 @@
-# Ruby CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/language-ruby/ for more details
-#
+# CircleCI 2.0 configuration file
 version: 2
-jobs:
-  build:
+x-defaults:
+  images:
     # TODO: bundler env variables --jobs=4 --retry=3
+    ruby: &image-ruby
+      image: "circleci/ruby:2.6.3"
+      environment:
+        BUNDLE_JOBS: "4"
+        BUNDLE_RETRY: "10"
+        BUNDLE_PATH: ../vendor/bundle
+        DEPLOY_ENV: "development"
+        RACK_ENV: "development"
+        POSTGRES_USER: "postgres"
+        POSTGRES_PASSWORD: ""
+        POSTGRES_HOST: "postgres"
+        POSTGRES_URI: "postgresql:///resources"
+  steps:
+    restore_cache: &step-restore_cache
+      restore_cache:
+        keys:
+          - v1-dependencies-{{ .Environment.CIRCLE_WORKFLOW_ID }}-{{ checksum "base/Gemfile.lock" }}
+    link_all: &step-link_all
+      run:
+        name: "link all services to the defaults"
+        command: "bin/local-link-all"
+workflows:
+  version: 2
+  primary:
+    jobs:
+      - setup
+      - lint:
+          requires:
+            - setup
+      - typecheck:
+          requires:
+            - setup
+      - build:
+          requires:
+            - setup
+jobs:
+  setup:
     docker:
-      - image: circleci/ruby:2.6.3
-        environment:
-          DEPLOY_ENV: "development"
-          RACK_ENV: "development"
-          POSTGRES_USER: "postgres"
-          POSTGRES_PASSWORD: ""
-          POSTGRES_HOST: "postgres"
-          POSTGRES_URI: "postgresql:///resources"
-      - image: circleci/postgres:11.2
+      - *image-ruby
+      - image: "circleci/postgres:11.2"
     steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v1-dependencies-{{ checksum "./_base/Gemfile.lock" }}
+      - "checkout"
+      - *step-restore_cache
+      - *step-link_all
+      - run:
+          name: "ensuring basic dependencies installed"
+          command: "sudo apt install postgresql-client"
       - run:
-          name: setup services
-          command: bin/local-setup
+          name: "wait for the database to be ready"
+          command: dockerize -wait tcp://localhost:5432 -timeout 1m
+      - run:
+          name: "setup the basics of the database"
+          command: "bin/local base ../.docker-compose/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh"
+      - run:
+          name: "install all libraries"
+          command: "bin/local base bundle install"
+      - run:
+          name: "run migrations"
+          command: "bin/local base bundle exec rake db:migrate"
       - save_cache:
-          paths:
-            - ./vendor/bundle
-          key: v1-dependencies-{{ checksum "./_base/Gemfile.lock" }}
+          paths: ["./vendor/bundle"]
+          key: v1-dependencies-{{ .Environment.CIRCLE_WORKFLOW_ID }}-{{ checksum "base/Gemfile.lock" }}
+  lint:
+    docker:
+      - *image-ruby
+    steps:
+      - "checkout"
+      - *step-restore_cache
+      - *step-link_all
+      - run:
+          name: "check against linter"
+          command: "bin/local-each bin/local-lint"
+  typecheck:
+    docker:
+      - *image-ruby
+    steps:
+      - "checkout"
+      - *step-restore_cache
+      - *step-link_all
+      - run:
+          name: "check against typechecker"
+          command: "bin/local-each bin/local-typecheck"
+  build:
+    machine: true
+    steps:
+      - "checkout"
+      - *step-restore_cache
+      - *step-link_all
       - run:
-          name: run tooling
-          command: "bin/local-check"
+          name: "build images"
+          command: "bin/local-each bin/docker-build-ci"
diff --git a/.docker-compose/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh b/.docker-compose/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh
new file mode 100755
index 0000000..1054574
--- /dev/null
+++ b/.docker-compose/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+set -e
+
+psql -v ON_ERROR_STOP=1 --host "$POSTGRES_HOST" --username "$POSTGRES_USERNAME" --dbname "template1" <<-EOSQL
+  BEGIN;
+    CREATE EXTENSION IF NOT EXISTS "citext";
+    CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+    CREATE EXTENSION IF NOT EXISTS "cube";
+    CREATE EXTENSION IF NOT EXISTS "btree_gin";
+    CREATE EXTENSION IF NOT EXISTS "btree_gist";
+    CREATE EXTENSION IF NOT EXISTS "hstore";
+    CREATE EXTENSION IF NOT EXISTS "isn";
+    CREATE EXTENSION IF NOT EXISTS "ltree";
+    CREATE EXTENSION IF NOT EXISTS "lo";
+    CREATE EXTENSION IF NOT EXISTS "fuzzystrmatch";
+    CREATE EXTENSION IF NOT EXISTS "pg_buffercache";
+    CREATE EXTENSION IF NOT EXISTS "pgrowlocks";
+    CREATE EXTENSION IF NOT EXISTS "pg_prewarm";
+    CREATE EXTENSION IF NOT EXISTS "pg_stat_statements";
+    CREATE EXTENSION IF NOT EXISTS "pg_trgm";
+    CREATE EXTENSION IF NOT EXISTS "tablefunc";
+  COMMIT;
+EOSQL
+psql -v --username "$POSTGRES_USERNAME" --host "$POSTGRES_HOST" --dbname "template1" <<-EOSQL
+  DROP DATABASE IF EXISTS "resources";
+  CREATE DATABASE "resources";
+  GRANT ALL PRIVILEGES ON DATABASE "resources" TO "postgres";
+EOSQL
\ No newline at end of file
diff --git a/.dockerignore b/.dockerignore
index 3a9be40..c65a394 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,10 +1,11 @@
 .bundle/
 .circleci/
+.DS_Store
+.gcloud/
 .git/
-.rubocop/
-services/
-gcloud/
+.gitpod/
+.docker-compose/
+.template/
 docs/
 tmp/
-.DS_Store
 .env
diff --git a/_gcloud/cloudbuild.yaml b/.gcloud/cloudbuild.yaml
similarity index 98%
rename from _gcloud/cloudbuild.yaml
rename to .gcloud/cloudbuild.yaml
index dae43de..e5a3a53 100644
--- a/_gcloud/cloudbuild.yaml
+++ b/.gcloud/cloudbuild.yaml
@@ -4,7 +4,7 @@ images:
   - "us.gcr.io/$PROJECT_ID/base:$SHORT_SHA"
   - "us.gcr.io/$PROJECT_ID/$_SERVICE_ID:latest"
   - "us.gcr.io/$PROJECT_ID/$_SERVICE_ID:$SHORT_SHA"
-timeout: "5m"
+timeout: "300s"
 steps:
   - name: "gcr.io/cloud-builders/docker"
     entrypoint: "sh"
diff --git a/.gitignore b/.gitignore
index 7aa861d..b8f3a3f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,7 +10,7 @@
 # Ignore all temporary files
 /tmp/*
 !/tmp/.keep
-/_services/*/data/
+/.docker-compose/*/data/
 
 # Ignore secret data
 /.env
@@ -32,4 +32,4 @@
 */.tool-versions
 
 # _base looks like linked information, but isn't
-!_base/*
+!base/*
diff --git a/.gitpod.yml b/.gitpod.yml
index 8a75798..d0e098a 100644
--- a/.gitpod.yml
+++ b/.gitpod.yml
@@ -1,6 +1,6 @@
 # The Docker image to run your workspace in. Defaults to gitpod/workspace-full
-image: gitpod/workspace-postgres
+image: "krainboltgreene/workspace:latest"
 tasks:
-  - command: "bin/service-automatic-create && bin/local-setup"
+  - command: "bin/local base ../.docker-compose/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh && bin/service-automatic-create && bin/local-setup"
 ports:
   - port: 8080
diff --git a/.gitpod/Dockerfile b/.gitpod/Dockerfile
new file mode 100644
index 0000000..f261e08
--- /dev/null
+++ b/.gitpod/Dockerfile
@@ -0,0 +1,17 @@
+FROM buildpack-deps:disco
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN yes | unminimize
+RUN apt-get update
+RUN apt-get install -yq bash-completion software-properties-common sudo
+RUN apt-get install -yq htop jq less multitail gnupg dirmngr postgresql postgresql-contrib postgresql-client ruby-full
+RUN apt-get clean && rm -rf /var/cache/apt/* /var/lib/apt/lists/* /tmp/*
+### Gitpod user ###
+# '-l': see https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user
+RUN useradd -l -u 33333 -G sudo -md /home/gitpod -s /bin/bash -p gitpod gitpod && sed -i.bkp -e 's/%sudo\s\+ALL=(ALL\(:ALL\)\?)\s\+ALL/%sudo ALL=NOPASSWD:ALL/g' /etc/sudoers
+ENV HOME /home/gitpod
+WORKDIR $HOME
+# custom Bash prompt
+RUN { echo && echo "PS1='\[\e]0;\u \w\a\]\[\033[01;32m\]\u\[\033[00m\] \[\033[01;34m\]\w\[\033[00m\] \\\$ '" ; } >> .bashrc
+# no root-owned files in the home directory
+RUN notOwnedFile=$(find . -not "(" -user gitpod -and -group gitpod ")" -print -quit) && { [ -z "$notOwnedFile" ] || { echo "Error: not all files/dirs in $HOME are owned by 'gitpod' user & group"; exit 1; } }
diff --git a/.local-env b/.local-env
index 51101f9..7847d5e 100644
--- a/.local-env
+++ b/.local-env
@@ -1,6 +1,6 @@
 export POSTGRES_URI=postgresql:///resources
 export POSTGRES_HOST=localhost
-export POSTGRES_USERNAME=gitpod
+export POSTGRES_USERNAME=postgres
 export POSTGRES_PASSWORD=
 export DEPLOY_ENV=development
 export RACK_ENV=development
diff --git a/_template/Dockerfile b/.template/Dockerfile
similarity index 100%
rename from _template/Dockerfile
rename to .template/Dockerfile
diff --git a/_template/function.rb b/.template/function.rb
similarity index 100%
rename from _template/function.rb
rename to .template/function.rb
diff --git a/.tool-versions b/.tool-versions
index a55039e..3903a11 100644
--- a/.tool-versions
+++ b/.tool-versions
@@ -1,4 +1,3 @@
 postgres 11.2
 ruby 2.6.3
 kubectl 1.14.1
-docker-slim 1.24
diff --git a/README.md b/README.md
index 9014958..ba46867 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,10 @@
 
 A framework for serverless ruby on top of cloud run and also a collection of services for the farsight service.
 
+## hints
+
+  - Inside a pry session you can type `Pry.reload!` to reload all of your ruby code.
+
 
 ## tools
 
@@ -23,6 +27,10 @@ bin/local-pry mtgjson-import
 
 Creates a pry session with the entire context of the service loaded.
 
+*bin/local-run {{service}}*
+
+Excutes the main function of the service without a web server, using a mock response, request, and the regular database.
+
 
 ## services
 
@@ -30,6 +38,7 @@ A service (or sometimes called function) is a singular semi-isolated piece of co
 
 For example, lets say we wanted a service that cleaned up old data. It would be called on a schedule (every 24h for example), it would pull all old records from the database, transform them to clean versions, and then store them in the database. Finally it would return status 200 (as a show that it completed successfully).
 
+
 ## how to setup
 
   0. Go to github.com/difference-engineers/farsight-functions
@@ -51,6 +60,13 @@ You'll know the process has worked because once gitpod has fully started your en
 Sometimes a service will need a specific library that most services wont need. For example, lets say you have a service that turns CSV documents into excel documents. You'll want to add the library like this:
 
 ```
-bin/local _base bundle add {{library}} --group={{service}}
-bin/local _base bundle add xlsx-reader --group=csv-to-xlsx
+bin/local base bundle add {{library}} --group={{service}}
+bin/local base bundle add xlsx-reader --group=mtgjson-import-cards
+```
+
+
+## How to think about services
+
+```
+(Data Gathering) -> (Decision Making) -> (Acting)
 ```
diff --git a/SERVICES b/SERVICES
index d3bdad4..6183594 100644
--- a/SERVICES
+++ b/SERVICES
@@ -1,3 +1,3 @@
 mtgjson-import-cards
+mtgjson-import-keywords
 mtgjson-import-sets
-mtgjson-import-keywords
\ No newline at end of file
diff --git a/_base/application.rb b/_base/application.rb
deleted file mode 100644
index bce918b..0000000
--- a/_base/application.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# typed: ignore
-class Application < Roda
-  plugin(:delete_empty_headers)
-  plugin(:request_headers)
-  plugin(:symbol_status)
-  plugin(:environments)
-  plugin(:caching)
-  plugin(:common_logger, LOGGER)
-  plugin(:cookies, :domain => "difference-engineers.com")
-  plugin(:early_hints)
-  plugin(:heartbeat)
-
-  route do |router|
-    router.root do
-      router.get do
-        # GET /
-        function(:request => request, :response => response, :database => ::DATABASE)
-      end
-    end
-  end
-end
diff --git a/_base/config.ru b/_base/config.ru
deleted file mode 100644
index 72e81f4..0000000
--- a/_base/config.ru
+++ /dev/null
@@ -1,17 +0,0 @@
-require_relative("boot")
-require_relative("configuration")
-require_relative("application")
-require_relative("database")
-require_relative("function")
-
-LOGGER.info("Service: #{SERVICE}")
-LOGGER.info("Rack Environment: #{ENV.fetch("RACK_ENV")}")
-LOGGER.info("Deploy Environment: #{ENV.fetch("DEPLOY_ENV")}")
-LOGGER.info("Concurrency: #{ENV.fetch("CONCURRENCY")}")
-
-use(Google::Cloud::Logging::Middleware) if PRODUCTION
-use(Google::Cloud::Debugger::Middleware) if PRODUCTION
-use(Google::Cloud::Trace::Middleware) if PRODUCTION
-use(Google::Cloud::ErrorReporting::Middleware) if PRODUCTION
-
-run(Application.freeze.app)
diff --git a/_base/mocks.rb b/_base/mocks.rb
deleted file mode 100644
index d16385d..0000000
--- a/_base/mocks.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-MOCK_REQUEST = OpenStruct.new
-MOCK_RESPONSE = Class.new do
-  def write(output)
-    puts(output)
-  end
-
-  def status=(statuses)
-    puts(statuses)
-  end
-  self
-end.new
diff --git a/_services/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh b/_services/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh
deleted file mode 100755
index 0cb9a78..0000000
--- a/_services/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-set -e
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USERNAME" --dbname "template1" <<-EOSQL
-  BEGIN;
-  CREATE EXTENSION IF NOT EXISTS "citext";
-  CREATE EXTENSION IF NOT EXISTS "pgcrypto";
-  CREATE EXTENSION IF NOT EXISTS "cube";
-  CREATE EXTENSION IF NOT EXISTS "btree_gin";
-  CREATE EXTENSION IF NOT EXISTS "btree_gist";
-  CREATE EXTENSION IF NOT EXISTS "hstore";
-  CREATE EXTENSION IF NOT EXISTS "isn";
-  CREATE EXTENSION IF NOT EXISTS "ltree";
-  CREATE EXTENSION IF NOT EXISTS "lo";
-  CREATE EXTENSION IF NOT EXISTS "fuzzystrmatch";
-  CREATE EXTENSION IF NOT EXISTS "pg_buffercache";
-  CREATE EXTENSION IF NOT EXISTS "pgrowlocks";
-  CREATE EXTENSION IF NOT EXISTS "pg_prewarm";
-  CREATE EXTENSION IF NOT EXISTS "pg_stat_statements";
-  CREATE EXTENSION IF NOT EXISTS "pg_trgm";
-  CREATE EXTENSION IF NOT EXISTS "tablefunc";
-  COMMIT;
-  DROP DATABASE IF EXISTS "resources";
-  CREATE DATABASE "resources";
-  GRANT ALL PRIVILEGES ON DATABASE "resources" TO "gitpod";
-EOSQL
\ No newline at end of file
diff --git a/_base/.rubocop/config.yml b/base/.rubocop/config.yml
similarity index 100%
rename from _base/.rubocop/config.yml
rename to base/.rubocop/config.yml
diff --git a/_base/Dockerfile b/base/Dockerfile
similarity index 94%
rename from _base/Dockerfile
rename to base/Dockerfile
index 99453af..b8064ac 100644
--- a/_base/Dockerfile
+++ b/base/Dockerfile
@@ -8,6 +8,7 @@ ENV CONCURRENCY 2
 WORKDIR /home/root/application/
 
 COPY db/migrate/ db/migrate/
+COPY middleware/ middleware/
 COPY boot.rb .
 COPY configuration.rb .
 COPY application.rb .
diff --git a/_base/Gemfile b/base/Gemfile
similarity index 79%
rename from _base/Gemfile
rename to base/Gemfile
index d20eb3c..1ff53b4 100644
--- a/_base/Gemfile
+++ b/base/Gemfile
@@ -4,14 +4,15 @@ ruby("2.6.3")
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}"}
 
-gem("roda", "~> 3.20")
-gem("falcon", "~> 0.30.0")
+gem("async", "~> 1.19")
+gem("async-http", "~> 0.48.0")
+gem("hanami-router", "~> 1.3", require: ["hanami/router", "hanami/middleware/body_parser"])
+gem("falcon", "0.34.2")
 gem("pg", "~> 1.1")
 gem("rom", "~> 5.0")
 gem("rom-sql", "~> 3.0")
-gem("semantic_logger", "~> 4.5")
 gem("rake", "~> 12.3")
-gem("async-http", "~> 0.40.3")
+gem("sorbet-runtime", "~> 0.4.4724")
 
 group(:production) do
   gem(
@@ -30,8 +31,7 @@ group(:development) do
   gem("rubocop-rspec", "~> 1.33")
   gem("rubocop-performance", "~> 1.4")
   gem("rubocop-thread_safety", "~> 0.3.4")
-  gem("sorbet", "~> 0.4.4394")
-  gem("sorbet-runtime", "~> 0.4.4394")
+  gem("sorbet", "~> 0.4.4724")
   gem("pry", "~> 0.12.2")
   gem("pry-doc", "~> 1.0")
   gem("pry-coolline", "~> 0.2.5")
diff --git a/_base/Gemfile.lock b/base/Gemfile.lock
similarity index 84%
rename from _base/Gemfile.lock
rename to base/Gemfile.lock
index c279f12..1937eba 100644
--- a/_base/Gemfile.lock
+++ b/base/Gemfile.lock
@@ -4,28 +4,28 @@ GEM
     addressable (2.6.0)
       public_suffix (>= 2.0.2, < 4.0)
     ast (2.4.0)
-    async (1.17.1)
+    async (1.20.1)
       console (~> 1.0)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-container (0.10.2)
+    async-container (0.14.1)
       async (~> 1.0)
       async-io (~> 1.4)
       process-group
-    async-http (0.40.3)
-      async (~> 1.14)
-      async-io (~> 1.18)
-      protocol-http (~> 0.3.0)
-      protocol-http1 (~> 0.5.0)
-      protocol-http2 (~> 0.2.0)
-    async-io (1.23.1)
+    async-http (0.48.2)
+      async (~> 1.19)
+      async-io (~> 1.25)
+      protocol-http (~> 0.12.0)
+      protocol-http1 (~> 0.9.0)
+      protocol-http2 (~> 0.9.0)
+    async-io (1.25.0)
       async (~> 1.14)
     binding_of_caller (0.8.0)
       debug_inspector (>= 0.0.1)
-    build-environment (1.10.1)
+    build-environment (1.11.0)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
-    console (1.2.4)
+    console (1.4.0)
     coolline (0.5.0)
       unicode_utils (~> 1.4)
     debug_inspector (0.0.3)
@@ -56,12 +56,12 @@ GEM
       dry-equalizer (~> 0.2, >= 0.2.2)
       dry-inflector (~> 0.1, >= 0.1.2)
       dry-logic (~> 1.0)
-    falcon (0.30.0)
+    falcon (0.34.2)
       async (~> 1.13)
-      async-container (~> 0.10.0)
-      async-http (~> 0.40.0)
+      async-container (~> 0.14.0)
+      async-http (~> 0.48.0)
       async-io (~> 1.22)
-      build-environment (~> 1.6)
+      build-environment (~> 1.11)
       localhost (~> 1.1)
       rack (>= 1.0)
       samovar (~> 2.1)
@@ -117,29 +117,39 @@ GEM
     grpc (1.20.0)
       google-protobuf (~> 3.7)
       googleapis-common-protos-types (~> 1.0.0)
+    hanami-router (1.3.1)
+      hanami-utils (~> 1.3)
+      http_router (= 0.11.2)
+      rack (~> 2.0)
+    hanami-utils (1.3.2)
+      concurrent-ruby (~> 1.0)
+      transproc (~> 1.0)
+    http_router (0.11.2)
+      rack (>= 1.0.0)
+      url_mount (~> 0.2.1)
     ice_nine (0.11.2)
     interception (0.5)
     jaro_winkler (1.5.3)
     jwt (2.2.1)
-    localhost (1.1.5)
+    localhost (1.1.6)
     mapping (1.1.1)
     memoist (0.16.0)
     method_source (0.9.2)
     multi_json (1.13.1)
     multipart-post (2.1.1)
-    nio4r (2.3.1)
+    nio4r (2.5.1)
     os (1.0.1)
     parallel (1.17.0)
     parser (2.6.3.0)
       ast (~> 2.4.0)
     pg (1.1.4)
     process-group (1.1.0)
-    protocol-hpack (1.0.0)
-    protocol-http (0.3.0)
-    protocol-http1 (0.5.0)
-      protocol-http (~> 0.2)
-    protocol-http2 (0.2.1)
-      protocol-hpack (~> 1.0)
+    protocol-hpack (1.4.1)
+    protocol-http (0.12.1)
+    protocol-http1 (0.9.0)
+      protocol-http (~> 0.5)
+    protocol-http2 (0.9.5)
+      protocol-hpack (~> 1.4)
       protocol-http (~> 0.2)
     pry (0.12.2)
       coderay (~> 1.1.0)
@@ -169,8 +179,6 @@ GEM
     rainbow (3.0.0)
     rake (12.3.2)
     rly (0.2.3)
-    roda (3.20.0)
-      rack
     rom (5.0.2)
       rom-changeset (~> 5.0, >= 5.0.1)
       rom-core (~> 5.0, >= 5.0.2)
@@ -216,8 +224,6 @@ GEM
     samovar (2.1.1)
       console (~> 1.0)
       mapping (~> 1.0)
-    semantic_logger (4.5.0)
-      concurrent-ruby (~> 1.0)
     sequel (5.20.0)
     signet (0.11.0)
       addressable (~> 2.3)
@@ -225,10 +231,10 @@ GEM
       jwt (>= 1.5, < 3.0)
       multi_json (~> 1.10)
     slop (3.6.0)
-    sorbet (0.4.4394)
-      sorbet-static (= 0.4.4394)
-    sorbet-runtime (0.4.4394)
-    sorbet-static (0.4.4394-universal-darwin-14)
+    sorbet (0.4.4724)
+      sorbet-static (= 0.4.4724)
+    sorbet-runtime (0.4.4724)
+    sorbet-static (0.4.4724-universal-darwin-14)
     stackdriver (0.15.3)
       google-cloud-debugger (~> 0.32)
       google-cloud-error_reporting (~> 0.30)
@@ -241,14 +247,18 @@ GEM
     unicode (0.4.4.4)
     unicode-display_width (1.6.0)
     unicode_utils (1.4.0)
+    url_mount (0.2.1)
+      rack
     yard (0.9.20)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  async-http (~> 0.40.3)
-  falcon (~> 0.30.0)
+  async (~> 1.19)
+  async-http (~> 0.48.0)
+  falcon (= 0.34.2)
+  hanami-router (~> 1.3)
   pg (~> 1.1)
   pry (~> 0.12.2)
   pry-auto_benching.rb (~> 3.2)
@@ -260,20 +270,18 @@ DEPENDENCIES
   pry-rescue (~> 1.5)
   pry-stack_explorer (~> 0.4.9)
   rake (~> 12.3)
-  roda (~> 3.20)
   rom (~> 5.0)
   rom-sql (~> 3.0)
   rubocop (~> 0.72.0)
   rubocop-performance (~> 1.4)
   rubocop-rspec (~> 1.33)
   rubocop-thread_safety (~> 0.3.4)
-  semantic_logger (~> 4.5)
-  sorbet (~> 0.4.4394)
-  sorbet-runtime (~> 0.4.4394)
+  sorbet (~> 0.4.4724)
+  sorbet-runtime (~> 0.4.4724)
   stackdriver (~> 0.15.3)
 
 RUBY VERSION
    ruby 2.6.3p62
 
 BUNDLED WITH
-   1.17.2
+   1.17.3
diff --git a/_base/Rakefile b/base/Rakefile
similarity index 85%
rename from _base/Rakefile
rename to base/Rakefile
index 6280c82..ba0af80 100644
--- a/_base/Rakefile
+++ b/base/Rakefile
@@ -2,6 +2,7 @@ require("rom/sql/rake_task")
 
 namespace(:db) do
   task(:setup) do
+    ENV["MIGRATING"] = "yes"
     require_relative("boot")
     require_relative("configuration")
     require_relative("database")
diff --git a/_base/boot.rb b/base/boot.rb
similarity index 80%
rename from _base/boot.rb
rename to base/boot.rb
index c031548..16ac664 100644
--- a/_base/boot.rb
+++ b/base/boot.rb
@@ -3,7 +3,4 @@
 require("rubygems")
 require("bundler")
 
-$stdout.sync = true
-$stderr.sync = true
-
 Bundler.require(:default, ENV.fetch("DEPLOY_ENV", "development"), ENV.fetch("SERVICE").to_sym)
diff --git a/base/config.ru b/base/config.ru
new file mode 100644
index 0000000..5c82cd2
--- /dev/null
+++ b/base/config.ru
@@ -0,0 +1,46 @@
+require_relative("boot")
+require_relative("configuration")
+require_relative("database")
+require_relative("function")
+require_relative("middleware/logger_setter_middleware")
+require_relative("middleware/database_setter_middleware")
+require_relative("middleware/request_setter_middleware")
+require_relative("middleware/status_symbol_middleware")
+
+Async.logger.info("Service: #{SERVICE}")
+Async.logger.info("Rack Environment: #{ENV.fetch("RACK_ENV")}")
+Async.logger.info("Deploy Environment: #{ENV.fetch("DEPLOY_ENV")}")
+Async.logger.info("Concurrency: #{ENV.fetch("CONCURRENCY")}")
+
+use(Google::Cloud::Logging::Middleware) if PRODUCTION
+use(Google::Cloud::Debugger::Middleware) if PRODUCTION
+use(Google::Cloud::Trace::Middleware) if PRODUCTION
+use(Google::Cloud::ErrorReporting::Middleware) if PRODUCTION
+use(Hanami::Middleware::BodyParser, :json)
+use(LoggerSetterMiddleware)
+use(DatabaseSetterMiddleware)
+use(RequestSetterMiddleware)
+use(StatusSymbolMiddleware)
+
+run(
+  Hanami::Router.new do
+    get "/" do |env|
+      function(request: env[:request], database: env[:database], logger: env[:logger])
+    end
+    post "/" do |env|
+      function(request: env[:request], database: env[:database], logger: env[:logger])
+    end
+    put "/" do |env|
+      function(request: env[:request], database: env[:database], logger: env[:logger])
+    end
+    patch "/" do |env|
+      function(request: env[:request], database: env[:database], logger: env[:logger])
+    end
+    delete "/" do |env|
+      function(request: env[:request], database: env[:database], logger: env[:logger])
+    end
+    trace "/" do |env|
+      function(request: env[:request], database: env[:database], logger: env[:logger])
+    end
+  end
+)
diff --git a/_base/configuration.rb b/base/configuration.rb
similarity index 63%
rename from _base/configuration.rb
rename to base/configuration.rb
index 3038423..fa07845 100644
--- a/_base/configuration.rb
+++ b/base/configuration.rb
@@ -2,11 +2,13 @@
 SERVICE = ENV.fetch("SERVICE") {ENV.fetch("K_SERVICE")}
 VERSION = ENV.fetch("VERSION") {ENV.fetch("K_REVISION").split(".").last}
 PRODUCTION = ENV.fetch("DEPLOY_ENV") == "production"
+CONSOLE = ENV.fetch("CONSOLE", "no") == "yes"
 
-SemanticLogger.default_level = :trace
-SemanticLogger.add_signal_handler
-SemanticLogger.add_appender(:io => $stdout, :formatter => :one_line) unless defined?(logger)
-LOGGER = SemanticLogger[SERVICE]
+if CONSOLE
+  def Pry.reload!
+    $LOADED_FEATURES.grep(/#{SERVICE}/).reject {|file| file.match?(/boot|config|application/)}.each(&method(:load))
+  end
+end
 
 if PRODUCTION
   Google::Cloud::Debugger.configure do |config|
diff --git a/_base/database.rb b/base/database.rb
similarity index 64%
rename from _base/database.rb
rename to base/database.rb
index 8b36a10..3ced4ed 100644
--- a/_base/database.rb
+++ b/base/database.rb
@@ -1,5 +1,6 @@
 # typed: ignore
-CONFIGURATION = {
+DATABASE = ROM.container(
+  :sql, ENV.fetch("POSTGRES_URI"),
   :encoding => "UTF8",
   :username => ENV.fetch("POSTGRES_USERNAME"),
   :password => ENV.fetch("POSTGRES_PASSWORD"),
@@ -17,13 +18,11 @@
     :caller_logging,
     :connection_expiration,
     :connection_validator,
-  ],
-}.freeze
-DATABASE = ROM.container(:sql, ENV.fetch("POSTGRES_URI"), CONFIGURATION) do |let|
-  let.gateways.fetch(:default).use_logger(LOGGER)
-  let.gateways.fetch(:default).run_migrations if let.gateways.fetch(:default).pending_migrations?
+  ]
+) do |let|
+  let.gateways.fetch(:default).use_logger(Async.logger)
 
-  unless let.gateways.fetch(:default).pending_migrations?
+  unless ENV["MIGRATING"]
     let.relation(:cards) do
       schema(:infer => true)
     end
diff --git a/_base/db/migrate/20190520034919_create_mtgjson_imports.rb b/base/db/migrate/20190520034919_create_mtgjson_imports.rb
similarity index 100%
rename from _base/db/migrate/20190520034919_create_mtgjson_imports.rb
rename to base/db/migrate/20190520034919_create_mtgjson_imports.rb
diff --git a/_base/db/migrate/20190520044832_create_cards.rb b/base/db/migrate/20190520044832_create_cards.rb
similarity index 100%
rename from _base/db/migrate/20190520044832_create_cards.rb
rename to base/db/migrate/20190520044832_create_cards.rb
diff --git a/_base/db/migrate/20190520044833_create_sets.rb b/base/db/migrate/20190520044833_create_sets.rb
similarity index 100%
rename from _base/db/migrate/20190520044833_create_sets.rb
rename to base/db/migrate/20190520044833_create_sets.rb
diff --git a/_base/db/migrate/20190728234954_add_type_to_mtgjson_imports.rb b/base/db/migrate/20190728234954_add_type_to_mtgjson_imports.rb
similarity index 72%
rename from _base/db/migrate/20190728234954_add_type_to_mtgjson_imports.rb
rename to base/db/migrate/20190728234954_add_type_to_mtgjson_imports.rb
index 060584a..98a92a0 100644
--- a/_base/db/migrate/20190728234954_add_type_to_mtgjson_imports.rb
+++ b/base/db/migrate/20190728234954_add_type_to_mtgjson_imports.rb
@@ -1,7 +1,7 @@
 ROM::SQL.migration do
   change do
     alter_table(:mtgjson_imports) do
-      add_column :type, :citext
+      add_column(:type, :citext)
     end
   end
 end
diff --git a/base/middleware/database_setter_middleware.rb b/base/middleware/database_setter_middleware.rb
new file mode 100644
index 0000000..2018d04
--- /dev/null
+++ b/base/middleware/database_setter_middleware.rb
@@ -0,0 +1,10 @@
+class DatabaseSetterMiddleware
+  def initialize(application)
+    @application = application
+  end
+
+  def call(environment)
+    environment[:database] = DATABASE
+    @application.call(environment)
+  end
+end
diff --git a/base/middleware/logger_setter_middleware.rb b/base/middleware/logger_setter_middleware.rb
new file mode 100644
index 0000000..9ca0cba
--- /dev/null
+++ b/base/middleware/logger_setter_middleware.rb
@@ -0,0 +1,39 @@
+class LoggerSetterMiddleware
+  FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f}
+
+  def initialize(application)
+    @application = application
+  end
+
+  def call(environment)
+    began_at = Rack::Utils.clock_time
+    environment[:logger] = Async.logger
+    environment[Rack::RACK_LOGGER] = Async.logger
+    status, header, body = @application.call(environment)
+    header = Rack::Utils::HeaderHash.new(header)
+    [status, header, Rack::BodyProxy.new(body) { log(environment, status, header, began_at) }]
+  end
+
+  private def log(env, status, header, began_at)
+    length = extract_content_length(header)
+
+    message = FORMAT % [
+      env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+      env["REMOTE_USER"] || "-",
+      Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+      env[Rack::REQUEST_METHOD],
+      env[Rack::PATH_INFO],
+      env[Rack::QUERY_STRING].empty? ? "" : "?#{env[Rack::QUERY_STRING]}",
+      env[Rack::HTTP_VERSION],
+      status.to_s[0..3],
+      length,
+      Rack::Utils.clock_time - began_at ]
+
+    env[Rack::RACK_LOGGER].info(message)
+  end
+
+  private def extract_content_length(headers)
+    value = headers[Rack::CONTENT_LENGTH]
+    !value || value.to_s == '0' ? '-' : value
+  end
+end
diff --git a/base/middleware/request_setter_middleware.rb b/base/middleware/request_setter_middleware.rb
new file mode 100644
index 0000000..5f70521
--- /dev/null
+++ b/base/middleware/request_setter_middleware.rb
@@ -0,0 +1,19 @@
+class RequestSetterMiddleware
+  def initialize(application)
+    @application = application
+  end
+
+  def call(environment)
+    environment[:request] = Rack::Request.new(environment)
+    environment["HTTP_X_REQUEST_ID"] ||= SecureRandom.uuid()
+    @application.call(environment)
+  end
+end
+module Rack::LogRequestID
+  def initialize(app); @app = app; end
+
+  def call(env)
+    puts "request_id=#{env['HTTP_X_REQUEST_ID']}"
+    @app.call(env)
+  end
+end
diff --git a/base/middleware/status_symbol_middleware.rb b/base/middleware/status_symbol_middleware.rb
new file mode 100644
index 0000000..fc9940c
--- /dev/null
+++ b/base/middleware/status_symbol_middleware.rb
@@ -0,0 +1,10 @@
+class StatusSymbolMiddleware
+  def initialize(application)
+    @application = application
+  end
+
+  def call(environment)
+    status, headers, body = @application.call(environment)
+    [if status.is_a?(Symbol) || status.is_a?(String) then Rack::Utils.status_code(status.to_sym) else status end, headers, body]
+  end
+end
diff --git a/base/mocks.rb b/base/mocks.rb
new file mode 100644
index 0000000..cef418e
--- /dev/null
+++ b/base/mocks.rb
@@ -0,0 +1 @@
+MOCK_REQUEST = OpenStruct.new
diff --git a/_base/sorbet/config b/base/sorbet/config
similarity index 100%
rename from _base/sorbet/config
rename to base/sorbet/config
diff --git a/base/sorbet/rbi/gems/ast.rbi b/base/sorbet/rbi/gems/ast.rbi
new file mode 100644
index 0000000..351e57c
--- /dev/null
+++ b/base/sorbet/rbi/gems/ast.rbi
@@ -0,0 +1,47 @@
+# 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/ast/all/ast.rbi
+#
+# ast-2.4.0
+module AST
+end
+class AST::Node
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def assign_properties(properties); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def dup; end
+  def eql?(other); end
+  def fancy_type; end
+  def hash; end
+  def initialize(type, children = nil, properties = nil); end
+  def inspect(indent = nil); end
+  def original_dup; end
+  def to_a; end
+  def to_ast; end
+  def to_s(indent = nil); end
+  def to_sexp(indent = nil); end
+  def to_sexp_array; end
+  def type; end
+  def updated(type = nil, children = nil, properties = nil); end
+end
+class AST::Processor
+  include AST::Processor::Mixin
+end
+module AST::Processor::Mixin
+  def handler_missing(node); end
+  def process(node); end
+  def process_all(nodes); end
+end
+module AST::Sexp
+  def s(type, *children); end
+end
diff --git a/base/sorbet/rbi/gems/jaro_winkler.rbi b/base/sorbet/rbi/gems/jaro_winkler.rbi
new file mode 100644
index 0000000..0763bfc
--- /dev/null
+++ b/base/sorbet/rbi/gems/jaro_winkler.rbi
@@ -0,0 +1,14 @@
+# 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/jaro_winkler/all/jaro_winkler.rbi
+#
+# jaro_winkler-1.5.3
+module JaroWinkler
+  def self.distance(*arg0); end
+  def self.jaro_distance(*arg0); end
+end
diff --git a/base/sorbet/rbi/gems/parallel.rbi b/base/sorbet/rbi/gems/parallel.rbi
new file mode 100644
index 0000000..7dbc77a
--- /dev/null
+++ b/base/sorbet/rbi/gems/parallel.rbi
@@ -0,0 +1,81 @@
+# 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/parallel/all/parallel.rbi
+#
+# parallel-1.17.0
+module Parallel
+  def self.add_progress_bar!(job_factory, options); end
+  def self.all?(*args, &block); end
+  def self.any?(*args, &block); end
+  def self.call_with_index(item, index, options, &block); end
+  def self.create_workers(job_factory, options, &block); end
+  def self.each(array, options = nil, &block); end
+  def self.each_with_index(array, options = nil, &block); end
+  def self.extract_count_from_options(options); end
+  def self.flat_map(*args, &block); end
+  def self.handle_exception(exception, results); end
+  def self.in_processes(options = nil, &block); end
+  def self.in_threads(options = nil); end
+  def self.map(source, options = nil, &block); end
+  def self.map_with_index(array, options = nil, &block); end
+  def self.process_incoming_jobs(read, write, job_factory, options, &block); end
+  def self.replace_worker(job_factory, workers, i, options, blk); end
+  def self.with_instrumentation(item, index, options); end
+  def self.work_direct(job_factory, options, &block); end
+  def self.work_in_processes(job_factory, options, &blk); end
+  def self.work_in_threads(job_factory, options, &block); end
+  def self.worker(job_factory, options, &block); end
+  def self.worker_number; end
+  def self.worker_number=(worker_num); end
+  extend Parallel::ProcessorCount
+end
+module Parallel::ProcessorCount
+  def physical_processor_count; end
+  def processor_count; end
+end
+class Parallel::DeadWorker < StandardError
+end
+class Parallel::Break < StandardError
+end
+class Parallel::Kill < StandardError
+end
+class Parallel::UndumpableException < StandardError
+  def backtrace; end
+  def initialize(original); end
+end
+class Parallel::ExceptionWrapper
+  def exception; end
+  def initialize(exception); end
+end
+class Parallel::Worker
+  def close_pipes; end
+  def initialize(read, write, pid); end
+  def pid; end
+  def read; end
+  def stop; end
+  def thread; end
+  def thread=(arg0); end
+  def wait; end
+  def work(data); end
+  def write; end
+end
+class Parallel::JobFactory
+  def initialize(source, mutex); end
+  def next; end
+  def pack(item, index); end
+  def producer?; end
+  def queue_wrapper(array); end
+  def size; end
+  def unpack(data); end
+end
+class Parallel::UserInterruptHandler
+  def self.kill(thing); end
+  def self.kill_on_ctrl_c(pids, options); end
+  def self.restore_interrupt(old, signal); end
+  def self.trap_interrupt(signal); end
+end
diff --git a/base/sorbet/rbi/gems/rainbow.rbi b/base/sorbet/rbi/gems/rainbow.rbi
new file mode 100644
index 0000000..711a5b8
--- /dev/null
+++ b/base/sorbet/rbi/gems/rainbow.rbi
@@ -0,0 +1,117 @@
+# 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/rainbow/all/rainbow.rbi
+#
+# rainbow-3.0.0
+module Rainbow
+  def self.enabled; end
+  def self.enabled=(value); end
+  def self.global; end
+  def self.new; end
+  def self.uncolor(string); end
+end
+class Rainbow::StringUtils
+  def self.uncolor(string); end
+  def self.wrap_with_sgr(string, codes); end
+end
+module Rainbow::X11ColorNames
+end
+class Rainbow::Color
+  def ground; end
+  def self.build(ground, values); end
+  def self.parse_hex_color(hex); end
+end
+class Rainbow::Color::Indexed < Rainbow::Color
+  def codes; end
+  def initialize(ground, num); end
+  def num; end
+end
+class Rainbow::Color::Named < Rainbow::Color::Indexed
+  def initialize(ground, name); end
+  def self.color_names; end
+  def self.valid_names; end
+end
+class Rainbow::Color::RGB < Rainbow::Color::Indexed
+  def b; end
+  def code_from_rgb; end
+  def codes; end
+  def g; end
+  def initialize(ground, *values); end
+  def r; end
+  def self.to_ansi_domain(value); end
+end
+class Rainbow::Color::X11Named < Rainbow::Color::RGB
+  def initialize(ground, name); end
+  def self.color_names; end
+  def self.valid_names; end
+  include Rainbow::X11ColorNames
+end
+class Rainbow::Presenter < String
+  def background(*values); end
+  def bg(*values); end
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright; end
+  def color(*values); end
+  def cyan; end
+  def dark; end
+  def faint; end
+  def fg(*values); end
+  def foreground(*values); end
+  def green; end
+  def hide; end
+  def inverse; end
+  def italic; end
+  def magenta; end
+  def method_missing(method_name, *args); end
+  def red; end
+  def reset; end
+  def respond_to_missing?(method_name, *args); end
+  def underline; end
+  def white; end
+  def wrap_with_sgr(codes); end
+  def yellow; end
+end
+class Rainbow::NullPresenter < String
+  def background(*_values); end
+  def bg(*_values); end
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright; end
+  def color(*_values); end
+  def cyan; end
+  def dark; end
+  def faint; end
+  def fg(*_values); end
+  def foreground(*_values); end
+  def green; end
+  def hide; end
+  def inverse; end
+  def italic; end
+  def magenta; end
+  def method_missing(method_name, *args); end
+  def red; end
+  def reset; end
+  def respond_to_missing?(method_name, *args); end
+  def underline; end
+  def white; end
+  def yellow; end
+end
+class Rainbow::Wrapper
+  def enabled; end
+  def enabled=(arg0); end
+  def initialize(enabled = nil); end
+  def wrap(string); end
+end
+class Object < BasicObject
+  def Rainbow(string); end
+end
diff --git a/base/sorbet/rbi/gems/rake.rbi b/base/sorbet/rbi/gems/rake.rbi
new file mode 100644
index 0000000..f89019b
--- /dev/null
+++ b/base/sorbet/rbi/gems/rake.rbi
@@ -0,0 +1,642 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi
+#
+# rake-12.3.2
+module Rake
+  def self.add_rakelib(*files); end
+  def self.application; end
+  def self.application=(app); end
+  def self.each_dir_parent(dir); end
+  def self.from_pathname(path); end
+  def self.load_rakefile(path); end
+  def self.original_dir; end
+  def self.suggested_thread_count; end
+  def self.with_application(block_application = nil); end
+  extend Rake::FileUtilsExt
+end
+module Rake::Version
+end
+class Module
+  def rake_extension(method); end
+end
+class String
+  def ext(newext = nil); end
+  def pathmap(spec = nil, &block); end
+  def pathmap_explode; end
+  def pathmap_partial(n); end
+  def pathmap_replace(patterns, &block); end
+end
+module Rake::Win32
+  def self.normalize(path); end
+  def self.win32_system_dir; end
+  def self.windows?; end
+end
+class Rake::Win32::Win32HomeError < RuntimeError
+end
+class Rake::LinkedList
+  def ==(other); end
+  def conj(item); end
+  def each; end
+  def empty?; end
+  def head; end
+  def initialize(head, tail = nil); end
+  def inspect; end
+  def self.cons(head, tail); end
+  def self.empty; end
+  def self.make(*args); end
+  def tail; end
+  def to_s; end
+  include Enumerable
+end
+class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList
+  def empty?; end
+  def initialize; end
+  def self.cons(head, tail); end
+end
+class Rake::CpuCounter
+  def count; end
+  def count_with_default(default = nil); end
+  def self.count; end
+end
+class Rake::Scope < Rake::LinkedList
+  def path; end
+  def path_with_task_name(task_name); end
+  def trim(n); end
+end
+class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList
+  def path; end
+  def path_with_task_name(task_name); end
+end
+class Rake::TaskArgumentError < ArgumentError
+end
+class Rake::RuleRecursionOverflowError < StandardError
+  def add_target(target); end
+  def initialize(*args); end
+  def message; end
+end
+module Rake::TaskManager
+  def [](task_name, scopes = nil); end
+  def add_location(task); end
+  def attempt_rule(task_name, task_pattern, args, extensions, block, level); end
+  def clear; end
+  def create_rule(*args, &block); end
+  def current_scope; end
+  def define_task(task_class, *args, &block); end
+  def enhance_with_matching_rule(task_name, level = nil); end
+  def find_location; end
+  def generate_did_you_mean_suggestions(task_name); end
+  def generate_message_for_undefined_task(task_name); end
+  def generate_name; end
+  def get_description(task); end
+  def in_namespace(name); end
+  def initialize; end
+  def intern(task_class, task_name); end
+  def last_description; end
+  def last_description=(arg0); end
+  def lookup(task_name, initial_scope = nil); end
+  def lookup_in_scope(name, scope); end
+  def make_sources(task_name, task_pattern, extensions); end
+  def resolve_args(args); end
+  def resolve_args_with_dependencies(args, hash); end
+  def resolve_args_without_dependencies(args); end
+  def self.record_task_metadata; end
+  def self.record_task_metadata=(arg0); end
+  def synthesize_file_task(task_name); end
+  def tasks; end
+  def tasks_in_scope(scope); end
+  def trace_rule(level, message); end
+end
+module Rake::Cloneable
+  def initialize_copy(source); end
+end
+module FileUtils
+  def create_shell_runner(cmd); end
+  def ruby(*args, &block); end
+  def safe_ln(*args); end
+  def set_verbose_option(options); end
+  def sh(*cmd, &block); end
+  def sh_show_command(cmd); end
+  def split_all(path); end
+end
+module Rake::FileUtilsExt
+  def cd(*args, &block); end
+  def chdir(*args, &block); end
+  def chmod(*args, &block); end
+  def chmod_R(*args, &block); end
+  def chown(*args, &block); end
+  def chown_R(*args, &block); end
+  def copy(*args, &block); end
+  def cp(*args, &block); end
+  def cp_lr(*args, &block); end
+  def cp_r(*args, &block); end
+  def install(*args, &block); end
+  def link(*args, &block); end
+  def ln(*args, &block); end
+  def ln_s(*args, &block); end
+  def ln_sf(*args, &block); end
+  def makedirs(*args, &block); end
+  def mkdir(*args, &block); end
+  def mkdir_p(*args, &block); end
+  def mkpath(*args, &block); end
+  def move(*args, &block); end
+  def mv(*args, &block); end
+  def nowrite(value = nil); end
+  def rake_check_options(options, *optdecl); end
+  def rake_merge_option(args, defaults); end
+  def rake_output_message(message); end
+  def remove(*args, &block); end
+  def rm(*args, &block); end
+  def rm_f(*args, &block); end
+  def rm_r(*args, &block); end
+  def rm_rf(*args, &block); end
+  def rmdir(*args, &block); end
+  def rmtree(*args, &block); end
+  def safe_unlink(*args, &block); end
+  def self.nowrite_flag; end
+  def self.nowrite_flag=(arg0); end
+  def self.verbose_flag; end
+  def self.verbose_flag=(arg0); end
+  def symlink(*args, &block); end
+  def touch(*args, &block); end
+  def verbose(value = nil); end
+  def when_writing(msg = nil); end
+  extend Rake::FileUtilsExt
+  include FileUtils
+end
+class Rake::FileList
+  def &(*args, &block); end
+  def *(other); end
+  def +(*args, &block); end
+  def -(*args, &block); end
+  def <<(obj); end
+  def <=>(*args, &block); end
+  def ==(array); end
+  def [](*args, &block); end
+  def []=(*args, &block); end
+  def add(*filenames); end
+  def add_matching(pattern); end
+  def all?(*args, &block); end
+  def any?(*args, &block); end
+  def append(*args, &block); end
+  def assoc(*args, &block); end
+  def at(*args, &block); end
+  def bsearch(*args, &block); end
+  def bsearch_index(*args, &block); end
+  def chain(*args, &block); end
+  def chunk(*args, &block); end
+  def chunk_while(*args, &block); end
+  def clear(*args, &block); end
+  def clear_exclude; end
+  def collect!(*args, &block); end
+  def collect(*args, &block); end
+  def collect_concat(*args, &block); end
+  def combination(*args, &block); end
+  def compact!(*args, &block); end
+  def compact(*args, &block); end
+  def concat(*args, &block); end
+  def count(*args, &block); end
+  def cycle(*args, &block); end
+  def delete(*args, &block); end
+  def delete_at(*args, &block); end
+  def delete_if(*args, &block); end
+  def detect(*args, &block); end
+  def difference(*args, &block); end
+  def dig(*args, &block); end
+  def drop(*args, &block); end
+  def drop_while(*args, &block); end
+  def each(*args, &block); end
+  def each_cons(*args, &block); end
+  def each_entry(*args, &block); end
+  def each_index(*args, &block); end
+  def each_slice(*args, &block); end
+  def each_with_index(*args, &block); end
+  def each_with_object(*args, &block); end
+  def egrep(pattern, *options); end
+  def empty?(*args, &block); end
+  def entries(*args, &block); end
+  def exclude(*patterns, &block); end
+  def excluded_from_list?(fn); end
+  def existing!; end
+  def existing; end
+  def ext(newext = nil); end
+  def fetch(*args, &block); end
+  def fill(*args, &block); end
+  def filter!(*args, &block); end
+  def filter(*args, &block); end
+  def find(*args, &block); end
+  def find_all(*args, &block); end
+  def find_index(*args, &block); end
+  def first(*args, &block); end
+  def flat_map(*args, &block); end
+  def flatten!(*args, &block); end
+  def flatten(*args, &block); end
+  def grep(*args, &block); end
+  def grep_v(*args, &block); end
+  def group_by(*args, &block); end
+  def gsub!(pat, rep); end
+  def gsub(pat, rep); end
+  def import(array); end
+  def include(*filenames); end
+  def include?(*args, &block); end
+  def index(*args, &block); end
+  def initialize(*patterns); end
+  def inject(*args, &block); end
+  def insert(*args, &block); end
+  def inspect(*args, &block); end
+  def is_a?(klass); end
+  def join(*args, &block); end
+  def keep_if(*args, &block); end
+  def kind_of?(klass); end
+  def last(*args, &block); end
+  def lazy(*args, &block); end
+  def length(*args, &block); end
+  def map!(*args, &block); end
+  def map(*args, &block); end
+  def max(*args, &block); end
+  def max_by(*args, &block); end
+  def member?(*args, &block); end
+  def min(*args, &block); end
+  def min_by(*args, &block); end
+  def minmax(*args, &block); end
+  def minmax_by(*args, &block); end
+  def none?(*args, &block); end
+  def one?(*args, &block); end
+  def pack(*args, &block); end
+  def partition(&block); end
+  def pathmap(spec = nil, &block); end
+  def permutation(*args, &block); end
+  def place(*args, &block); end
+  def pop(*args, &block); end
+  def prepend(*args, &block); end
+  def product(*args, &block); end
+  def push(*args, &block); end
+  def rassoc(*args, &block); end
+  def reduce(*args, &block); end
+  def reject!(*args, &block); end
+  def reject(*args, &block); end
+  def repeated_combination(*args, &block); end
+  def repeated_permutation(*args, &block); end
+  def replace(*args, &block); end
+  def resolve; end
+  def resolve_add(fn); end
+  def resolve_exclude; end
+  def reverse!(*args, &block); end
+  def reverse(*args, &block); end
+  def reverse_each(*args, &block); end
+  def rindex(*args, &block); end
+  def rotate!(*args, &block); end
+  def rotate(*args, &block); end
+  def sample(*args, &block); end
+  def select!(*args, &block); end
+  def select(*args, &block); end
+  def self.[](*args); end
+  def self.glob(pattern, *args); end
+  def shelljoin(*args, &block); end
+  def shift(*args, &block); end
+  def shuffle!(*args, &block); end
+  def shuffle(*args, &block); end
+  def size(*args, &block); end
+  def slice!(*args, &block); end
+  def slice(*args, &block); end
+  def slice_after(*args, &block); end
+  def slice_before(*args, &block); end
+  def slice_when(*args, &block); end
+  def sort!(*args, &block); end
+  def sort(*args, &block); end
+  def sort_by!(*args, &block); end
+  def sort_by(*args, &block); end
+  def sub!(pat, rep); end
+  def sub(pat, rep); end
+  def sum(*args, &block); end
+  def take(*args, &block); end
+  def take_while(*args, &block); end
+  def to_a; end
+  def to_ary; end
+  def to_h(*args, &block); end
+  def to_s; end
+  def to_set(*args, &block); end
+  def transpose(*args, &block); end
+  def union(*args, &block); end
+  def uniq!(*args, &block); end
+  def uniq(*args, &block); end
+  def unshift(*args, &block); end
+  def values_at(*args, &block); end
+  def zip(*args, &block); end
+  def |(*args, &block); end
+  include Rake::Cloneable
+end
+class Rake::Promise
+  def chore; end
+  def complete?; end
+  def discard; end
+  def error?; end
+  def initialize(args, &block); end
+  def recorder; end
+  def recorder=(arg0); end
+  def result?; end
+  def stat(*args); end
+  def value; end
+  def work; end
+end
+class Rake::ThreadPool
+  def __queue__; end
+  def future(*args, &block); end
+  def gather_history; end
+  def history; end
+  def initialize(thread_count); end
+  def join; end
+  def process_queue_item; end
+  def safe_thread_count; end
+  def start_thread; end
+  def stat(event, data = nil); end
+  def statistics; end
+end
+module Rake::PrivateReader
+  def self.included(base); end
+end
+module Rake::PrivateReader::ClassMethods
+  def private_reader(*names); end
+end
+class Rake::ThreadHistoryDisplay
+  def initialize(stats); end
+  def items; end
+  def rename(hash, key, renames); end
+  def show; end
+  def stats; end
+  def threads; end
+  extend Rake::PrivateReader::ClassMethods
+  include Rake::PrivateReader
+end
+module Rake::TraceOutput
+  def trace_on(out, *strings); end
+end
+class Rake::CommandLineOptionError < StandardError
+end
+class Rake::Application
+  def add_import(fn); end
+  def add_loader(ext, loader); end
+  def collect_command_line_tasks(args); end
+  def default_task_name; end
+  def deprecate(old_usage, new_usage, call_site); end
+  def display_cause_details(ex); end
+  def display_error_message(ex); end
+  def display_exception_backtrace(ex); end
+  def display_exception_details(ex); end
+  def display_exception_details_seen; end
+  def display_exception_message_details(ex); end
+  def display_prerequisites; end
+  def display_tasks_and_comments; end
+  def dynamic_width; end
+  def dynamic_width_stty; end
+  def dynamic_width_tput; end
+  def exit_because_of_exception(ex); end
+  def find_rakefile_location; end
+  def glob(path, &block); end
+  def handle_options(argv); end
+  def has_cause?(ex); end
+  def has_chain?(exception); end
+  def have_rakefile; end
+  def init(app_name = nil, argv = nil); end
+  def initialize; end
+  def invoke_task(task_string); end
+  def load_imports; end
+  def load_rakefile; end
+  def name; end
+  def options; end
+  def original_dir; end
+  def parse_task_string(string); end
+  def print_rakefile_directory(location); end
+  def rake_require(file_name, paths = nil, loaded = nil); end
+  def rakefile; end
+  def rakefile_location(backtrace = nil); end
+  def raw_load_rakefile; end
+  def run(argv = nil); end
+  def run_with_threads; end
+  def select_tasks_to_show(options, show_tasks, value); end
+  def select_trace_output(options, trace_option, value); end
+  def set_default_options; end
+  def sort_options(options); end
+  def standard_exception_handling; end
+  def standard_rake_options; end
+  def standard_system_dir; end
+  def system_dir; end
+  def terminal_columns; end
+  def terminal_columns=(arg0); end
+  def terminal_width; end
+  def thread_pool; end
+  def top_level; end
+  def top_level_tasks; end
+  def trace(*strings); end
+  def truncate(string, width); end
+  def truncate_output?; end
+  def tty_output=(arg0); end
+  def tty_output?; end
+  def unix?; end
+  def windows?; end
+  include Rake::TaskManager
+  include Rake::TraceOutput
+end
+class Rake::PseudoStatus
+  def >>(n); end
+  def exited?; end
+  def exitstatus; end
+  def initialize(code = nil); end
+  def stopped?; end
+  def to_i; end
+end
+class Rake::TaskArguments
+  def [](index); end
+  def each(&block); end
+  def extras; end
+  def fetch(*args, &block); end
+  def has_key?(key); end
+  def initialize(names, values, parent = nil); end
+  def inspect; end
+  def key?(key); end
+  def lookup(name); end
+  def method_missing(sym, *args); end
+  def names; end
+  def new_scope(names); end
+  def to_a; end
+  def to_hash; end
+  def to_s; end
+  def values_at(*keys); end
+  def with_defaults(defaults); end
+  include Enumerable
+end
+class Rake::InvocationChain < Rake::LinkedList
+  def append(invocation); end
+  def member?(invocation); end
+  def prefix; end
+  def self.append(invocation, chain); end
+  def to_s; end
+end
+class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList
+  def append(invocation); end
+  def member?(obj); end
+  def to_s; end
+end
+module Rake::InvocationExceptionMixin
+  def chain; end
+  def chain=(value); end
+end
+class Rake::Task
+  def actions; end
+  def add_chain_to(exception, new_chain); end
+  def add_comment(comment); end
+  def add_description(description); end
+  def all_prerequisite_tasks; end
+  def already_invoked; end
+  def application; end
+  def application=(arg0); end
+  def arg_description; end
+  def arg_names; end
+  def clear; end
+  def clear_actions; end
+  def clear_args; end
+  def clear_comments; end
+  def clear_prerequisites; end
+  def collect_prerequisites(seen); end
+  def comment; end
+  def comment=(comment); end
+  def enhance(deps = nil, &block); end
+  def execute(args = nil); end
+  def first_sentence(string); end
+  def format_trace_flags; end
+  def full_comment; end
+  def initialize(task_name, app); end
+  def inspect; end
+  def investigation; end
+  def invoke(*args); end
+  def invoke_prerequisites(task_args, invocation_chain); end
+  def invoke_prerequisites_concurrently(task_args, invocation_chain); end
+  def invoke_with_call_chain(task_args, invocation_chain); end
+  def locations; end
+  def lookup_prerequisite(prerequisite_name); end
+  def name; end
+  def name_with_args; end
+  def needed?; end
+  def prereqs; end
+  def prerequisite_tasks; end
+  def prerequisites; end
+  def reenable; end
+  def scope; end
+  def self.[](task_name); end
+  def self.clear; end
+  def self.create_rule(*args, &block); end
+  def self.define_task(*args, &block); end
+  def self.scope_name(scope, task_name); end
+  def self.task_defined?(task_name); end
+  def self.tasks; end
+  def set_arg_names(args); end
+  def source; end
+  def sources; end
+  def sources=(arg0); end
+  def timestamp; end
+  def to_s; end
+  def transform_comments(separator, &block); end
+end
+class Rake::EarlyTime
+  def <=>(other); end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  def to_s; end
+  extend Singleton::SingletonClassMethods
+  include Comparable
+  include Singleton
+end
+class Rake::FileTask < Rake::Task
+  def needed?; end
+  def out_of_date?(stamp); end
+  def self.scope_name(scope, task_name); end
+  def timestamp; end
+end
+class Rake::FileCreationTask < Rake::FileTask
+  def needed?; end
+  def timestamp; end
+end
+class Rake::MultiTask < Rake::Task
+  def invoke_prerequisites(task_args, invocation_chain); end
+end
+module Rake::DSL
+  def cd(*args, &block); end
+  def chdir(*args, &block); end
+  def chmod(*args, &block); end
+  def chmod_R(*args, &block); end
+  def chown(*args, &block); end
+  def chown_R(*args, &block); end
+  def copy(*args, &block); end
+  def cp(*args, &block); end
+  def cp_lr(*args, &block); end
+  def cp_r(*args, &block); end
+  def desc(description); end
+  def directory(*args, &block); end
+  def file(*args, &block); end
+  def file_create(*args, &block); end
+  def import(*fns); end
+  def install(*args, &block); end
+  def link(*args, &block); end
+  def ln(*args, &block); end
+  def ln_s(*args, &block); end
+  def ln_sf(*args, &block); end
+  def makedirs(*args, &block); end
+  def mkdir(*args, &block); end
+  def mkdir_p(*args, &block); end
+  def mkpath(*args, &block); end
+  def move(*args, &block); end
+  def multitask(*args, &block); end
+  def mv(*args, &block); end
+  def namespace(name = nil, &block); end
+  def nowrite(value = nil); end
+  def rake_check_options(options, *optdecl); end
+  def rake_merge_option(args, defaults); end
+  def rake_output_message(message); end
+  def remove(*args, &block); end
+  def rm(*args, &block); end
+  def rm_f(*args, &block); end
+  def rm_r(*args, &block); end
+  def rm_rf(*args, &block); end
+  def rmdir(*args, &block); end
+  def rmtree(*args, &block); end
+  def ruby(*args, &block); end
+  def rule(*args, &block); end
+  def safe_ln(*args); end
+  def safe_unlink(*args, &block); end
+  def sh(*cmd, &block); end
+  def split_all(path); end
+  def symlink(*args, &block); end
+  def task(*args, &block); end
+  def touch(*args, &block); end
+  def verbose(value = nil); end
+  def when_writing(msg = nil); end
+  include Rake::FileUtilsExt
+end
+class Rake::DefaultLoader
+  def load(fn); end
+end
+class Rake::LateTime
+  def <=>(other); end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  def to_s; end
+  extend Singleton::SingletonClassMethods
+  include Comparable
+  include Singleton
+end
+class Rake::NameSpace
+  def [](name); end
+  def initialize(task_manager, scope_list); end
+  def scope; end
+  def tasks; end
+end
+module Rake::Backtrace
+  def self.collapse(backtrace); end
+end
diff --git a/base/sorbet/rbi/gems/ruby-progressbar.rbi b/base/sorbet/rbi/gems/ruby-progressbar.rbi
new file mode 100644
index 0000000..47ac9e7
--- /dev/null
+++ b/base/sorbet/rbi/gems/ruby-progressbar.rbi
@@ -0,0 +1,304 @@
+# 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/ruby-progressbar/all/ruby-progressbar.rbi
+#
+# ruby-progressbar-1.10.1
+class ProgressBar
+  def self.create(*args); end
+end
+class ProgressBar::Output
+  def bar; end
+  def bar=(arg0); end
+  def clear_string; end
+  def initialize(options = nil); end
+  def length; end
+  def length_calculator; end
+  def length_calculator=(arg0); end
+  def log(string); end
+  def print_and_flush; end
+  def refresh(options = nil); end
+  def self.detect(options = nil); end
+  def stream; end
+  def stream=(arg0); end
+  def throttle; end
+  def throttle=(arg0); end
+  def with_refresh; end
+end
+module ProgressBar::Outputs
+end
+class ProgressBar::Outputs::Tty < ProgressBar::Output
+  def bar_update_string; end
+  def clear; end
+  def default_format; end
+  def eol; end
+  def refresh_with_format_change; end
+  def resolve_format(other_format); end
+end
+class ProgressBar::Outputs::NonTty < ProgressBar::Output
+  def bar_update_string; end
+  def clear; end
+  def default_format; end
+  def eol; end
+  def last_update_length; end
+  def last_update_length=(arg0); end
+  def refresh_with_format_change(*arg0); end
+  def resolve_format(*arg0); end
+end
+class ProgressBar::Time
+  def initialize(time = nil); end
+  def now; end
+  def time; end
+  def time=(arg0); end
+  def unmocked_time_method; end
+end
+class ProgressBar::Timer
+  def divide_seconds(seconds); end
+  def elapsed_seconds; end
+  def elapsed_whole_seconds; end
+  def initialize(options = nil); end
+  def pause; end
+  def reset; end
+  def reset?; end
+  def restart; end
+  def resume; end
+  def start; end
+  def started?; end
+  def started_at; end
+  def started_at=(arg0); end
+  def stop; end
+  def stopped?; end
+  def stopped_at; end
+  def stopped_at=(arg0); end
+  def time; end
+  def time=(arg0); end
+end
+class ProgressBar::InvalidProgressError < RuntimeError
+end
+class ProgressBar::Progress
+  def absolute; end
+  def decrement; end
+  def finish; end
+  def finished?; end
+  def increment; end
+  def initialize(options = nil); end
+  def none?; end
+  def percentage_completed; end
+  def percentage_completed_with_precision; end
+  def progress; end
+  def progress=(new_progress); end
+  def reset; end
+  def running_average; end
+  def running_average=(arg0); end
+  def smoothing; end
+  def smoothing=(arg0); end
+  def start(options = nil); end
+  def starting_position; end
+  def starting_position=(arg0); end
+  def total; end
+  def total=(new_total); end
+  def total_with_unknown_indicator; end
+  def unknown?; end
+end
+class ProgressBar::Throttle
+  def choke(options = nil); end
+  def initialize(options = nil); end
+  def rate; end
+  def rate=(arg0); end
+  def started_at; end
+  def started_at=(arg0); end
+  def stopped_at; end
+  def stopped_at=(arg0); end
+  def timer; end
+  def timer=(arg0); end
+end
+module ProgressBar::Calculators
+end
+class ProgressBar::Calculators::Length
+  def calculate_length; end
+  def current_length; end
+  def current_length=(arg0); end
+  def dynamic_width; end
+  def dynamic_width_stty; end
+  def dynamic_width_tput; end
+  def dynamic_width_via_io_object; end
+  def dynamic_width_via_output_stream_object; end
+  def dynamic_width_via_system_calls; end
+  def initialize(options = nil); end
+  def length; end
+  def length_changed?; end
+  def length_override; end
+  def length_override=(other); end
+  def output; end
+  def output=(arg0); end
+  def reset_length; end
+  def terminal_width; end
+  def unix?; end
+end
+class ProgressBar::Calculators::RunningAverage
+  def self.calculate(current_average, new_value_to_average, smoothing_factor); end
+end
+module ProgressBar::Components
+end
+class ProgressBar::Components::Bar
+  def bar(length); end
+  def bar_with_percentage(length); end
+  def complete_bar(length); end
+  def complete_bar_with_percentage(length); end
+  def completed_length; end
+  def incomplete_space(length); end
+  def incomplete_string; end
+  def initialize(options = nil); end
+  def integrated_percentage_complete_string; end
+  def length; end
+  def length=(arg0); end
+  def progress; end
+  def progress=(arg0); end
+  def progress_mark; end
+  def progress_mark=(arg0); end
+  def remainder_mark; end
+  def remainder_mark=(arg0); end
+  def standard_complete_string; end
+  def to_s(options = nil); end
+  def unknown_progress_frame; end
+  def unknown_string; end
+  def upa_steps; end
+  def upa_steps=(arg0); end
+end
+class ProgressBar::Components::Percentage
+  def initialize(options = nil); end
+  def justified_percentage; end
+  def justified_percentage_with_precision; end
+  def percentage; end
+  def percentage_with_precision; end
+  def progress; end
+  def progress=(arg0); end
+end
+class ProgressBar::Components::Rate
+  def base_rate; end
+  def elapsed_seconds; end
+  def initialize(options = nil); end
+  def progress; end
+  def progress=(arg0); end
+  def rate_of_change(format_string = nil); end
+  def rate_of_change_with_precision; end
+  def rate_scale; end
+  def rate_scale=(arg0); end
+  def scaled_rate; end
+  def started_at; end
+  def started_at=(arg0); end
+  def stopped_at; end
+  def stopped_at=(arg0); end
+  def timer; end
+  def timer=(arg0); end
+end
+class ProgressBar::Components::Time
+  def elapsed; end
+  def elapsed_with_label; end
+  def estimated; end
+  def estimated_seconds_remaining; end
+  def estimated_with_elapsed_fallback; end
+  def estimated_with_friendly_oob; end
+  def estimated_with_label; end
+  def estimated_with_no_oob; end
+  def estimated_with_unknown_oob; end
+  def initialize(options = nil); end
+  def out_of_bounds_time; end
+  def out_of_bounds_time_format; end
+  def out_of_bounds_time_format=(format); end
+  def progress; end
+  def progress=(arg0); end
+  def timer; end
+  def timer=(arg0); end
+end
+class ProgressBar::Components::Title
+  def initialize(options = nil); end
+  def title; end
+  def title=(arg0); end
+end
+module ProgressBar::Format
+end
+class ProgressBar::Format::Molecule
+  def bar_molecule?; end
+  def full_key; end
+  def initialize(letter); end
+  def key; end
+  def key=(arg0); end
+  def lookup_value(environment, length = nil); end
+  def method_name; end
+  def method_name=(arg0); end
+  def non_bar_molecule?; end
+end
+class ProgressBar::Format::Formatter
+  def self.process(format_string, max_length, bar); end
+end
+class ProgressBar::Format::String < String
+  def bar_molecule_placeholder_length; end
+  def bar_molecules; end
+  def displayable_length; end
+  def molecules; end
+  def non_bar_molecules; end
+end
+class ProgressBar::Base
+  def autofinish; end
+  def autofinish=(arg0); end
+  def autostart; end
+  def autostart=(arg0); end
+  def bar; end
+  def bar=(arg0); end
+  def clear(*args, &block); end
+  def decrement; end
+  def finish; end
+  def finished; end
+  def finished=(arg0); end
+  def finished?; end
+  def format(other); end
+  def format=(other); end
+  def increment; end
+  def initialize(options = nil); end
+  def inspect; end
+  def log(*args, &block); end
+  def output; end
+  def output=(arg0); end
+  def pause; end
+  def paused?; end
+  def percentage; end
+  def percentage=(arg0); end
+  def progress(*args, &block); end
+  def progress=(new_progress); end
+  def progress_mark=(mark); end
+  def progressable; end
+  def progressable=(arg0); end
+  def rate; end
+  def rate=(arg0); end
+  def refresh(*args, &block); end
+  def remainder_mark=(mark); end
+  def reset; end
+  def resume; end
+  def start(options = nil); end
+  def started?; end
+  def stop; end
+  def stopped?; end
+  def time; end
+  def time=(arg0); end
+  def timer; end
+  def timer=(arg0); end
+  def title; end
+  def title=(title); end
+  def title_comp; end
+  def title_comp=(arg0); end
+  def to_h; end
+  def to_s(new_format = nil); end
+  def total(*args, &block); end
+  def total=(new_total); end
+  def update_progress(*args); end
+  extend Forwardable
+end
+module ProgressBar::Refinements
+end
+module ProgressBar::Refinements::Enumerator
+end
diff --git a/base/sorbet/rbi/gems/unicode-display_width.rbi b/base/sorbet/rbi/gems/unicode-display_width.rbi
new file mode 100644
index 0000000..2121bbb
--- /dev/null
+++ b/base/sorbet/rbi/gems/unicode-display_width.rbi
@@ -0,0 +1,16 @@
+# 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/unicode-display_width/all/unicode-display_width.rbi
+#
+# unicode-display_width-1.6.0
+module Unicode
+end
+module Unicode::DisplayWidth
+  def self.emoji_extra_width_of(string, ambiguous = nil, overwrite = nil, _ = nil); end
+  def self.of(string, ambiguous = nil, overwrite = nil, options = nil); end
+end
diff --git a/base/sorbet/rbi/gems/yard.rbi b/base/sorbet/rbi/gems/yard.rbi
new file mode 100644
index 0000000..5dd5c05
--- /dev/null
+++ b/base/sorbet/rbi/gems/yard.rbi
@@ -0,0 +1,739 @@
+# 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/yard/all/yard.rbi
+#
+# yard-0.9.20
+module YARD
+  def self.load_plugins; end
+  def self.parse(*args); end
+  def self.parse_string(*args); end
+  def self.ruby18?; end
+  def self.ruby19?; end
+  def self.ruby2?; end
+  def self.windows?; end
+end
+module YARD::Server
+  def self.register_static_path(path); end
+end
+class Object < BasicObject
+  def P(namespace, name = nil, type = nil); end
+  def log; end
+end
+module YARD::CLI
+end
+module YARD::CodeObjects
+  extend YARD::CodeObjects::NamespaceMapper
+end
+module YARD::Handlers
+end
+module YARD::Handlers::Common
+end
+module YARD::Handlers::C
+end
+module YARD::Handlers::Ruby
+end
+module YARD::Handlers::Ruby::Legacy
+end
+module YARD::I18n
+end
+module YARD::Parser
+end
+module YARD::Parser::C
+end
+module YARD::Parser::Ruby
+end
+module YARD::Parser::Ruby::Legacy
+end
+module YARD::Rake
+end
+module YARD::Serializers
+end
+module YARD::Server::Commands
+end
+module YARD::Tags
+end
+module YARD::Templates
+end
+module YARD::Templates::Helpers
+end
+module YARD::Templates::Helpers::Markup
+end
+class YARD::Config
+  def self.add_ignored_plugins_file; end
+  def self.arguments; end
+  def self.load; end
+  def self.load_autoload_plugins; end
+  def self.load_commandline_plugins; end
+  def self.load_commandline_safemode; end
+  def self.load_gem_plugins; end
+  def self.load_plugin(name); end
+  def self.load_plugin_failed(name, exception); end
+  def self.load_plugins; end
+  def self.options; end
+  def self.options=(arg0); end
+  def self.read_config_file; end
+  def self.save; end
+  def self.translate_plugin_name(name); end
+  def self.translate_plugin_names; end
+  def self.with_yardopts; end
+end
+class Insertion
+  def after(val, recursive = nil); end
+  def after_any(val); end
+  def before(val, recursive = nil); end
+  def before_any(val); end
+  def initialize(list, value); end
+  def insertion(val, rel, recursive = nil, list = nil); end
+end
+class SymbolHash < Hash
+  def [](key); end
+  def []=(key, value); end
+  def delete(key); end
+  def has_key?(key); end
+  def initialize(symbolize_value = nil); end
+  def key?(key); end
+  def merge!(hash); end
+  def merge(hash); end
+  def self.[](*hsh); end
+  def update(hash); end
+end
+class File < IO
+  def self.cleanpath(path, rel_root = nil); end
+  def self.empty?(arg0); end
+  def self.read_binary(file); end
+  def self.relative_path(from, to); end
+end
+class Module
+  def class_name; end
+end
+class String
+  def shell_split; end
+end
+class Array
+  def place(*values); end
+end
+module Gem
+  def self.source_index; end
+end
+class Gem::SourceIndex
+  def ==(other); end
+  def add_spec(gem_spec, name = nil); end
+  def add_specs(*gem_specs); end
+  def all_gems; end
+  def dump; end
+  def each(&block); end
+  def find_name(gem_name, requirement = nil); end
+  def gem_signature(gem_full_name); end
+  def gems; end
+  def index_signature; end
+  def initialize(specifications = nil); end
+  def latest_specs(include_prerelease = nil); end
+  def length; end
+  def load_gems_in(*spec_dirs); end
+  def outdated; end
+  def prerelease_gems; end
+  def prerelease_specs; end
+  def refresh!; end
+  def released_gems; end
+  def released_specs; end
+  def remove_spec(full_name); end
+  def search(gem_pattern, platform_only = nil); end
+  def self.from_gems_in(*spec_dirs); end
+  def self.from_installed_gems(*deprecated); end
+  def self.installed_spec_directories; end
+  def self.load_specification(file_name); end
+  def size; end
+  def spec_dirs; end
+  def spec_dirs=(arg0); end
+  def specification(full_name); end
+  include Enumerable
+end
+class YARD::Options
+  def ==(other); end
+  def [](key); end
+  def []=(key, value); end
+  def delete(key); end
+  def each; end
+  def inspect; end
+  def merge(opts); end
+  def method_missing(meth, *args, &block); end
+  def reset_defaults; end
+  def self.default_attr(key, default); end
+  def to_hash; end
+  def update(opts); end
+end
+class YARD::Templates::TemplateOptions < YARD::Options
+  def __globals; end
+  def default_return; end
+  def default_return=(arg0); end
+  def embed_mixins; end
+  def embed_mixins=(arg0); end
+  def embed_mixins_match?(mixin); end
+  def format; end
+  def format=(arg0); end
+  def globals; end
+  def globals=(arg0); end
+  def hide_void_return; end
+  def hide_void_return=(arg0); end
+  def highlight; end
+  def highlight=(arg0); end
+  def index; end
+  def index=(arg0); end
+  def markup; end
+  def markup=(arg0); end
+  def markup_provider; end
+  def markup_provider=(arg0); end
+  def no_highlight; end
+  def no_highlight=(value); end
+  def object; end
+  def object=(arg0); end
+  def owner; end
+  def owner=(arg0); end
+  def page_title; end
+  def page_title=(arg0); end
+  def serialize; end
+  def serialize=(arg0); end
+  def serializer; end
+  def serializer=(arg0); end
+  def template; end
+  def template=(arg0); end
+  def type; end
+  def type=(arg0); end
+  def verifier; end
+  def verifier=(arg0); end
+end
+class YARD::CLI::Command
+  def common_options(opts); end
+  def description; end
+  def load_script(file); end
+  def parse_options(opts, args); end
+  def self.run(*args); end
+  def unrecognized_option(err); end
+end
+class YARD::CLI::YardoptsCommand < YARD::CLI::Command
+  def initialize; end
+  def options_file; end
+  def options_file=(arg0); end
+  def parse_arguments(*args); end
+  def parse_rdoc_document_file(file = nil); end
+  def parse_yardopts(file = nil); end
+  def parse_yardopts_options(*args); end
+  def support_rdoc_document_file!(file = nil); end
+  def use_document_file; end
+  def use_document_file=(arg0); end
+  def use_yardopts_file; end
+  def use_yardopts_file=(arg0); end
+  def yardopts(file = nil); end
+  def yardopts_options(opts); end
+end
+class YARD::CLI::YardocOptions < YARD::Templates::TemplateOptions
+  def file; end
+  def file=(arg0); end
+  def files; end
+  def files=(arg0); end
+  def format; end
+  def format=(arg0); end
+  def index; end
+  def index=(arg0); end
+  def item; end
+  def item=(arg0); end
+  def locale; end
+  def locale=(arg0); end
+  def objects; end
+  def objects=(arg0); end
+  def onefile; end
+  def onefile=(arg0); end
+  def readme; end
+  def readme=(arg0); end
+  def serializer; end
+  def serializer=(arg0); end
+  def title; end
+  def title=(arg0); end
+  def verifier; end
+  def verifier=(arg0); end
+end
+class YARD::CLI::Yardoc < YARD::CLI::YardoptsCommand
+  def add_api_verifier; end
+  def add_extra_files(*files); end
+  def add_tag(tag_data, factory_method = nil); end
+  def add_visibility_verifier; end
+  def all_objects; end
+  def apis; end
+  def apis=(arg0); end
+  def apply_locale; end
+  def assets; end
+  def assets=(arg0); end
+  def copy_assets; end
+  def description; end
+  def excluded; end
+  def excluded=(arg0); end
+  def extra_file_valid?(file, check_exists = nil); end
+  def fail_on_warning; end
+  def fail_on_warning=(arg0); end
+  def files; end
+  def files=(arg0); end
+  def general_options(opts); end
+  def generate; end
+  def generate=(arg0); end
+  def has_markup; end
+  def has_markup=(arg0); end
+  def hidden_apis; end
+  def hidden_apis=(arg0); end
+  def hidden_tags; end
+  def hidden_tags=(arg0); end
+  def initialize; end
+  def list; end
+  def list=(arg0); end
+  def options; end
+  def optparse(*args); end
+  def output_options(opts); end
+  def parse_arguments(*args); end
+  def parse_files(*files); end
+  def print_list; end
+  def run(*args); end
+  def run_generate(checksums); end
+  def run_verifier(list); end
+  def save_yardoc; end
+  def save_yardoc=(arg0); end
+  def statistics; end
+  def statistics=(arg0); end
+  def tag_options(opts); end
+  def use_cache; end
+  def use_cache=(arg0); end
+  def verify_markup_options; end
+  def visibilities; end
+  def visibilities=(arg0); end
+end
+module YARD::Registry
+  def self.[](path); end
+  def self.all(*types); end
+  def self.at(path); end
+  def self.checksum_for(data); end
+  def self.checksums; end
+  def self.clear; end
+  def self.delete(object); end
+  def self.delete_from_disk; end
+  def self.each(&block); end
+  def self.global_yardoc_file(spec, for_writing = nil); end
+  def self.instance; end
+  def self.load!(file = nil); end
+  def self.load(files = nil, reparse = nil); end
+  def self.load_all; end
+  def self.load_yardoc(file = nil); end
+  def self.local_yardoc_file(spec, for_writing = nil); end
+  def self.locale(name); end
+  def self.lock_for_writing(file = nil, &block); end
+  def self.locked_for_writing?(file = nil); end
+  def self.old_global_yardoc_file(spec, for_writing = nil); end
+  def self.partial_resolve(namespace, name, type = nil); end
+  def self.paths(reload = nil); end
+  def self.po_dir; end
+  def self.po_dir=(dir); end
+  def self.proxy_types; end
+  def self.register(object); end
+  def self.resolve(namespace, name, inheritance = nil, proxy_fallback = nil, type = nil); end
+  def self.root; end
+  def self.save(merge = nil, file = nil); end
+  def self.single_object_db; end
+  def self.single_object_db=(v); end
+  def self.thread_local_resolver; end
+  def self.thread_local_store; end
+  def self.thread_local_store=(value); end
+  def self.yardoc_file; end
+  def self.yardoc_file=(v); end
+  def self.yardoc_file_for_gem(gem, ver_require = nil, for_writing = nil); end
+  extend Enumerable
+end
+class YARD::RegistryStore
+  def [](key); end
+  def []=(key, value); end
+  def all_disk_objects; end
+  def checksums; end
+  def checksums_path; end
+  def delete(key); end
+  def destroy(force = nil); end
+  def file; end
+  def get(key); end
+  def initialize; end
+  def keys(reload = nil); end
+  def load!(file = nil); end
+  def load(file = nil); end
+  def load_all; end
+  def load_checksums; end
+  def load_locale(name); end
+  def load_object_types; end
+  def load_proxy_types; end
+  def load_root; end
+  def load_yardoc; end
+  def load_yardoc_old; end
+  def locale(name); end
+  def lock_for_writing(file = nil, &block); end
+  def locked_for_writing?(file = nil); end
+  def object_types_path; end
+  def objects_path; end
+  def paths_for_type(type, reload = nil); end
+  def proxy_types; end
+  def proxy_types_path; end
+  def put(key, value); end
+  def root; end
+  def save(merge = nil, file = nil); end
+  def values(reload = nil); end
+  def values_for_type(type, reload = nil); end
+  def write_checksums; end
+  def write_complete_lock; end
+  def write_object_types; end
+  def write_proxy_types; end
+end
+module YARD::CodeObjects::NamespaceMapper
+  def clear_separators; end
+  def default_separator(value = nil); end
+  def register_separator(sep, *valid_types); end
+  def self.default_separator; end
+  def self.default_separator=(arg0); end
+  def self.invalidate; end
+  def self.map; end
+  def self.map_match; end
+  def self.rev_map; end
+  def separators; end
+  def separators_for_type(type); end
+  def separators_match; end
+  def types_for_separator(sep); end
+end
+class YARD::CodeObjects::CodeObjectList < Array
+  def <<(value); end
+  def initialize(owner = nil); end
+  def push(value); end
+end
+class YARD::CodeObjects::Base
+  def ==(other); end
+  def [](key); end
+  def []=(key, value); end
+  def add_file(file, line = nil, has_comments = nil); end
+  def add_tag(*tags); end
+  def base_docstring; end
+  def copy_to(other); end
+  def copyable_attributes; end
+  def docstring(locale = nil); end
+  def docstring=(comments); end
+  def dynamic; end
+  def dynamic=(arg0); end
+  def dynamic?; end
+  def eql?(other); end
+  def equal?(other); end
+  def file; end
+  def files; end
+  def format(options = nil); end
+  def format_source(source); end
+  def group; end
+  def group=(arg0); end
+  def has_tag?(name); end
+  def hash; end
+  def initialize(namespace, name, *arg2); end
+  def inspect; end
+  def line; end
+  def method_missing(meth, *args, &block); end
+  def name(prefix = nil); end
+  def namespace; end
+  def namespace=(obj); end
+  def parent; end
+  def parent=(obj); end
+  def path; end
+  def relative_path(other); end
+  def root?; end
+  def self.===(other); end
+  def self.new(namespace, name, *args, &block); end
+  def sep; end
+  def signature; end
+  def signature=(arg0); end
+  def source; end
+  def source=(statement); end
+  def source_type; end
+  def source_type=(arg0); end
+  def tag(name); end
+  def tags(name = nil); end
+  def title; end
+  def to_ary; end
+  def to_s; end
+  def translate_docstring(locale); end
+  def type; end
+  def visibility; end
+  def visibility=(v); end
+end
+class YARD::CodeObjects::NamespaceObject < YARD::CodeObjects::Base
+  def aliases; end
+  def attributes; end
+  def child(opts = nil); end
+  def children; end
+  def class_attributes; end
+  def class_mixins; end
+  def constants(opts = nil); end
+  def cvars; end
+  def groups; end
+  def groups=(arg0); end
+  def included_constants; end
+  def included_meths(opts = nil); end
+  def initialize(namespace, name, *args, &block); end
+  def instance_attributes; end
+  def instance_mixins; end
+  def meths(opts = nil); end
+  def mixins(*scopes); end
+end
+class YARD::CodeObjects::ModuleObject < YARD::CodeObjects::NamespaceObject
+  def inheritance_tree(include_mods = nil); end
+end
+class YARD::CodeObjects::RootObject < YARD::CodeObjects::ModuleObject
+  def equal?(other); end
+  def hash; end
+  def inspect; end
+  def path; end
+  def root?; end
+  def title; end
+end
+class YARD::DocstringParser
+  def call_after_parse_callbacks; end
+  def call_directives_after_parse; end
+  def create_directive(tag_name, tag_buf); end
+  def create_ref_tag(tag_name, name, object_name); end
+  def create_tag(tag_name, tag_buf = nil); end
+  def detect_reference(content); end
+  def directives; end
+  def directives=(arg0); end
+  def handler; end
+  def handler=(arg0); end
+  def initialize(library = nil); end
+  def library; end
+  def library=(arg0); end
+  def namespace; end
+  def object; end
+  def object=(arg0); end
+  def parse(content, object = nil, handler = nil); end
+  def parse_content(content); end
+  def post_process; end
+  def raw_text; end
+  def raw_text=(arg0); end
+  def reference; end
+  def reference=(arg0); end
+  def self.after_parse(&block); end
+  def self.after_parse_callbacks; end
+  def state; end
+  def state=(arg0); end
+  def tag_is_directive?(tag_name); end
+  def tags; end
+  def tags=(arg0); end
+  def text; end
+  def text=(arg0); end
+  def to_docstring; end
+end
+class YARD::Docstring < String
+  def +(other); end
+  def add_tag(*tags); end
+  def all; end
+  def all=(content, parse = nil); end
+  def blank?(only_visible_tags = nil); end
+  def convert_ref_tags; end
+  def delete_tag_if(&block); end
+  def delete_tags(name); end
+  def dup; end
+  def has_tag?(name); end
+  def hash_flag; end
+  def hash_flag=(v); end
+  def initialize(content = nil, object = nil); end
+  def line; end
+  def line_range; end
+  def line_range=(arg0); end
+  def object; end
+  def object=(arg0); end
+  def parse_comments(comments); end
+  def ref_tags; end
+  def replace(content, parse = nil); end
+  def resolve_reference; end
+  def self.default_parser; end
+  def self.default_parser=(arg0); end
+  def self.new!(text, tags = nil, object = nil, raw_data = nil, ref_object = nil); end
+  def self.parser(*args); end
+  def stable_sort_by(list); end
+  def summary; end
+  def tag(name); end
+  def tags(name = nil); end
+  def to_raw; end
+  def to_s; end
+end
+class YARD::Serializers::Base
+  def after_serialize(data); end
+  def before_serialize; end
+  def exists?(object); end
+  def initialize(opts = nil); end
+  def options; end
+  def serialize(object, data); end
+  def serialized_path(object); end
+end
+class YARD::Serializers::FileSystemSerializer < YARD::Serializers::Base
+  def basepath; end
+  def basepath=(value); end
+  def build_filename_map; end
+  def encode_path_components(*components); end
+  def exists?(object); end
+  def extension; end
+  def extension=(value); end
+  def initialize(opts = nil); end
+  def mapped_name(object); end
+  def serialize(object, data); end
+  def serialized_path(object); end
+end
+class YARD::StubProxy
+  def _dump(_depth); end
+  def hash; end
+  def initialize(path, transient = nil); end
+  def method_missing(meth, *args, &block); end
+  def self._load(str); end
+end
+class YARD::Serializers::YardocSerializer < YARD::Serializers::FileSystemSerializer
+  def checksums_path; end
+  def complete?; end
+  def complete_lock_path; end
+  def deserialize(path, is_path = nil); end
+  def dump(object); end
+  def initialize(yfile); end
+  def internal_dump(object, first_object = nil); end
+  def lock_for_writing; end
+  def locked_for_writing?; end
+  def object_types_path; end
+  def objects_path; end
+  def processing_path; end
+  def proxy_types_path; end
+  def serialize(object); end
+  def serialized_path(object); end
+end
+class YARD::Logger < Logger
+  def <<(msg = nil); end
+  def add(*args); end
+  def backtrace(exc, level_meth = nil); end
+  def capture(msg, nontty_log = nil); end
+  def clear_line; end
+  def clear_progress; end
+  def debug(*args); end
+  def enter_level(new_level = nil); end
+  def format_log(sev, _time, _prog, msg); end
+  def initialize(pipe, *args); end
+  def io; end
+  def io=(pipe); end
+  def print(msg = nil); end
+  def print_no_newline(msg); end
+  def progress(msg, nontty_log = nil); end
+  def puts(msg = nil); end
+  def self.instance(pipe = nil); end
+  def show_backtraces; end
+  def show_backtraces=(arg0); end
+  def show_progress; end
+  def show_progress=(arg0); end
+  def warn(*args); end
+  def warn_no_continuations; end
+  def warned; end
+  def warned=(arg0); end
+end
+class YARD::CodeObjects::ClassObject < YARD::CodeObjects::NamespaceObject
+  def constants(opts = nil); end
+  def inheritance_tree(include_mods = nil); end
+  def inherited_constants; end
+  def inherited_meths(opts = nil); end
+  def initialize(namespace, name, *args, &block); end
+  def is_exception?; end
+  def meths(opts = nil); end
+  def superclass; end
+  def superclass=(object); end
+end
+class YARD::CodeObjects::ProxyMethodError < NoMethodError
+end
+class YARD::CodeObjects::Proxy
+  def <=>(other); end
+  def ==(other); end
+  def ===(other); end
+  def class; end
+  def equal?(other); end
+  def hash; end
+  def initialize(namespace, name, type = nil); end
+  def inspect; end
+  def instance_of?(klass); end
+  def is_a?(klass); end
+  def kind_of?(klass); end
+  def method_missing(meth, *args, &block); end
+  def name(prefix = nil); end
+  def namespace; end
+  def parent; end
+  def path; end
+  def proxy_path; end
+  def respond_to?(meth, include_private = nil); end
+  def root?; end
+  def self.===(other); end
+  def title; end
+  def to_ary; end
+  def to_obj; end
+  def to_s; end
+  def to_str; end
+  def type; end
+  def type=(type); end
+end
+class YARD::CodeObjects::MethodObject < YARD::CodeObjects::Base
+  def aliases; end
+  def attr_info; end
+  def constructor?; end
+  def copyable_attributes; end
+  def explicit; end
+  def explicit=(arg0); end
+  def initialize(namespace, name, scope = nil, &block); end
+  def is_alias?; end
+  def is_attribute?; end
+  def is_explicit?; end
+  def module_function?; end
+  def name(prefix = nil); end
+  def overridden_method; end
+  def parameters; end
+  def parameters=(arg0); end
+  def path; end
+  def reader?; end
+  def scope; end
+  def scope=(v); end
+  def sep; end
+  def writer?; end
+end
+class YARD::Tags::Tag
+  def explain_types; end
+  def initialize(tag_name, text, types = nil, name = nil); end
+  def name; end
+  def name=(arg0); end
+  def object; end
+  def object=(arg0); end
+  def tag_name; end
+  def tag_name=(arg0); end
+  def text; end
+  def text=(arg0); end
+  def type; end
+  def types; end
+  def types=(arg0); end
+end
+class YARD::Tags::OverloadTag < YARD::Tags::Tag
+  def docstring; end
+  def has_tag?(name); end
+  def initialize(tag_name, text); end
+  def is_a?(other); end
+  def kind_of?(other); end
+  def method_missing(*args, &block); end
+  def name(prefix = nil); end
+  def object=(value); end
+  def parameters; end
+  def parse_signature; end
+  def parse_tag(text); end
+  def signature; end
+  def tag(name); end
+  def tags(name = nil); end
+  def type; end
+end
+class YARD::CodeObjects::ConstantObject < YARD::CodeObjects::Base
+  def value; end
+  def value=(value); end
+end
diff --git a/_base/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi b/base/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
similarity index 52%
rename from _base/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
rename to base/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
index 3263382..f9762bd 100644
--- a/_base/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
+++ b/base/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
@@ -8,900 +8,933 @@
 # typed: strict
 
 module Bundler
-  FREEBSD = ::T.let(nil, ::T.untyped)
-  NULL = ::T.let(nil, ::T.untyped)
-  ORIGINAL_ENV = ::T.let(nil, ::T.untyped)
-  SUDO_MUTEX = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-  WINDOWS = ::T.let(nil, ::T.untyped)
+  FREEBSD = ::T.let(nil, T.untyped)
+  NULL = ::T.let(nil, T.untyped)
+  ORIGINAL_ENV = ::T.let(nil, T.untyped)
+  SUDO_MUTEX = ::T.let(nil, T.untyped)
+  VERSION = ::T.let(nil, T.untyped)
+  WINDOWS = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      custom_path: ::T.untyped,
+      custom_path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.app_cache(custom_path=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.app_config_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.bin_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.bundle_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.bundler_major_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.clean_env(); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.clean_exec(*args); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.clean_system(*args); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.clear_gemspec_cache(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.configure(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.configured_bundle_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.current_ruby(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.default_bundle_dir(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.default_gemfile(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.default_lockfile(); end
 
   sig do
     params(
-      unlock: ::T.untyped,
+      unlock: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.definition(unlock=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.environment(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.feature_flag(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.frozen_bundle?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.git_present?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.home(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.install_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.load(); end
 
   sig do
     params(
-      file: ::T.untyped,
-      validate: ::T.untyped,
+      file: T.untyped,
+      validate: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.load_gemspec(file, validate=T.unsafe(nil)); end
 
   sig do
     params(
-      file: ::T.untyped,
-      validate: ::T.untyped,
+      file: T.untyped,
+      validate: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.load_gemspec_uncached(file, validate=T.unsafe(nil)); end
 
   sig do
     params(
-      data: ::T.untyped,
+      data: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.load_marshal(data); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.local_platform(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.locked_gems(); end
 
   sig do
     params(
-      path: ::T.untyped,
-      options: ::T.untyped,
+      path: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir_p(path, options=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.original_env(); end
 
   sig do
     params(
-      file: ::T.untyped,
+      file: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.read_file(file); end
 
   sig do
     params(
-      groups: ::T.untyped,
+      groups: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.require(*groups); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.require_thor_actions(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.requires_sudo?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.reset!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.reset_paths!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.reset_rubygems!(); end
 
   sig do
     params(
-      path: ::T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_rf(path); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.root(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.ruby_scope(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.rubygems(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.settings(); end
 
   sig do
     params(
-      groups: ::T.untyped,
+      groups: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.setup(*groups); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.specs_path(); end
 
   sig do
     params(
-      str: ::T.untyped,
+      str: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.sudo(str); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.system_bindir(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.tmp(name=T.unsafe(nil)); end
 
   sig do
     params(
-      login: ::T.untyped,
-      warning: ::T.untyped,
+      login: T.untyped,
+      warning: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.tmp_home_path(login, warning); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.ui(); end
 
   sig do
     params(
-      ui: ::T.untyped,
+      ui: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ui=(ui); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.use_system_gems?(); end
 
   sig do
     params(
-      dir: ::T.untyped,
+      dir: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.user_bundle_path(dir=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.user_cache(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.user_home(); end
 
   sig do
     params(
-      executable: ::T.untyped,
+      executable: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.which(executable); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.with_clean_env(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.with_original_env(); end
 end
 
 class Bundler::APIResponseMismatchError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 module Bundler::BuildMetadata
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.built_at(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.git_commit_sha(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.release?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.to_h(); end
 end
 
 class Bundler::BundlerError < StandardError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.all_errors(); end
 
   sig do
     params(
-      code: ::T.untyped,
+      code: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.status_code(code); end
 end
 
 class Bundler::CurrentRuby
-  KNOWN_MAJOR_VERSIONS = ::T.let(nil, ::T.untyped)
-  KNOWN_MINOR_VERSIONS = ::T.let(nil, ::T.untyped)
-  KNOWN_PLATFORMS = ::T.let(nil, ::T.untyped)
+  KNOWN_MAJOR_VERSIONS = ::T.let(nil, T.untyped)
+  KNOWN_MINOR_VERSIONS = ::T.let(nil, T.untyped)
+  KNOWN_PLATFORMS = ::T.let(nil, T.untyped)
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def jruby_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def jruby_27?(); end
+
+  sig {returns(T.untyped)}
   def jruby_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def maglev_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def maglev_27?(); end
+
+  sig {returns(T.untyped)}
   def maglev_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mingw_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def mingw_27?(); end
+
+  sig {returns(T.untyped)}
   def mingw_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mri_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def mri_27?(); end
+
+  sig {returns(T.untyped)}
   def mri_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin64_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def mswin64_27?(); end
+
+  sig {returns(T.untyped)}
   def mswin64_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def mswin_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def mswin_27?(); end
+
+  sig {returns(T.untyped)}
   def mswin_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def on_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def on_27?(); end
+
+  sig {returns(T.untyped)}
   def on_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rbx_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def rbx_27?(); end
+
+  sig {returns(T.untyped)}
   def rbx_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def ruby_27?(); end
+
+  sig {returns(T.untyped)}
   def ruby_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def truffleruby_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def truffleruby_27?(); end
+
+  sig {returns(T.untyped)}
   def truffleruby_2?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_18?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_19?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_1?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_20?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_21?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_22?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_23?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_24?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_25?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def x64_mingw_26?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
+  def x64_mingw_27?(); end
+
+  sig {returns(T.untyped)}
   def x64_mingw_2?(); end
 end
 
 class Bundler::CyclicDependencyError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::Definition
   include ::Bundler::GemHelpers
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def add_current_platform(); end
 
   sig do
     params(
-      platform: ::T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_platform(platform); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def current_dependencies(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      explicit_flag: ::T.untyped,
+      explicit_flag: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ensure_equivalent_gemfile_and_lockfile(explicit_flag=T.unsafe(nil)); end
 
   sig do
     params(
-      current_spec: ::T.untyped,
+      current_spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_indexed_specs(current_spec); end
 
   sig do
     params(
-      current_spec: ::T.untyped,
+      current_spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_resolved_spec(current_spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_version_promoter(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gemfiles(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def groups(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def has_local_dependencies?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def has_rubygems_remotes?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def index(); end
 
   sig do
     params(
-      lockfile: ::T.untyped,
-      dependencies: ::T.untyped,
-      sources: ::T.untyped,
-      unlock: ::T.untyped,
-      ruby_version: ::T.untyped,
-      optional_groups: ::T.untyped,
-      gemfiles: ::T.untyped,
+      lockfile: T.untyped,
+      dependencies: T.untyped,
+      sources: T.untyped,
+      unlock: T.untyped,
+      ruby_version: T.untyped,
+      optional_groups: T.untyped,
+      gemfiles: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(lockfile, dependencies, sources, unlock, ruby_version=T.unsafe(nil), optional_groups=T.unsafe(nil), gemfiles=T.unsafe(nil)); end
 
   sig do
     params(
-      file: ::T.untyped,
-      preserve_unknown_sections: ::T.untyped,
+      file: T.untyped,
+      preserve_unknown_sections: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def lock(file, preserve_unknown_sections=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def locked_bundler_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def locked_deps(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def locked_gems(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def locked_ruby_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def locked_ruby_version_object(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def lockfile(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def missing_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def missing_specs?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def new_platform?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def new_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def nothing_changed?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platforms(); end
 
   sig do
     params(
-      platform: ::T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remove_platform(platform); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def removed_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requested_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requires(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def resolve(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def resolve_remotely!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def resolve_with_cache!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def spec_git_paths(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 
   sig do
     params(
-      groups: ::T.untyped,
+      groups: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def specs_for(groups); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_lock(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unlocking?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def validate_platforms!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def validate_ruby!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def validate_runtime!(); end
 
   sig do
     params(
-      gemfile: ::T.untyped,
-      lockfile: ::T.untyped,
-      unlock: ::T.untyped,
+      gemfile: T.untyped,
+      lockfile: T.untyped,
+      unlock: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.build(gemfile, lockfile, unlock); end
 end
@@ -909,1076 +942,1076 @@ end
 class Bundler::DepProxy
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def __platform(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dep(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
   sig do
     params(
-      dep: ::T.untyped,
-      platform: ::T.untyped,
+      dep: T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(dep, platform); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def type(); end
 end
 
 class Bundler::Dependency < Gem::Dependency
-  PLATFORM_MAP = ::T.let(nil, ::T.untyped)
-  REVERSE_PLATFORM_MAP = ::T.let(nil, ::T.untyped)
+  PLATFORM_MAP = ::T.let(nil, T.untyped)
+  REVERSE_PLATFORM_MAP = ::T.let(nil, T.untyped)
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def autorequire(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def current_env?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def current_platform?(); end
 
   sig do
     params(
-      valid_platforms: ::T.untyped,
+      valid_platforms: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def gem_platforms(valid_platforms); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gemfile(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def groups(); end
 
   sig do
     params(
-      name: ::T.untyped,
-      version: ::T.untyped,
-      options: ::T.untyped,
-      blk: ::T.untyped,
+      name: T.untyped,
+      version: T.untyped,
+      options: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, version, options=T.unsafe(nil), &blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platforms(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def should_include?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specific?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_lock(); end
 end
 
 class Bundler::DeprecatedError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::Dsl
   include ::Bundler::RubyDsl
-  VALID_KEYS = ::T.let(nil, ::T.untyped)
-  VALID_PLATFORMS = ::T.let(nil, ::T.untyped)
+  VALID_KEYS = ::T.let(nil, T.untyped)
+  VALID_PLATFORMS = ::T.let(nil, T.untyped)
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
+      dependencies: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies=(dependencies); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def env(name); end
 
   sig do
     params(
-      gemfile: ::T.untyped,
-      contents: ::T.untyped,
+      gemfile: T.untyped,
+      contents: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eval_gemfile(gemfile, contents=T.unsafe(nil)); end
 
   sig do
     params(
-      name: ::T.untyped,
-      args: ::T.untyped,
+      name: T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def gem(name, *args); end
 
   sig do
     params(
-      opts: ::T.untyped,
+      opts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def gemspec(opts=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gemspecs(); end
 
   sig do
     params(
-      uri: ::T.untyped,
-      options: ::T.untyped,
-      blk: ::T.untyped,
+      uri: T.untyped,
+      options: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def git(uri, options=T.unsafe(nil), &blk); end
 
   sig do
     params(
-      name: ::T.untyped,
-      block: ::T.untyped,
+      name: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def git_source(name, &block); end
 
   sig do
     params(
-      repo: ::T.untyped,
-      options: ::T.untyped,
+      repo: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def github(repo, options=T.unsafe(nil)); end
 
   sig do
     params(
-      args: ::T.untyped,
-      blk: ::T.untyped,
+      args: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def group(*args, &blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install_if(*args); end
 
   sig do
     params(
-      name: ::T.untyped,
-      args: ::T.untyped,
+      name: T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def method_missing(name, *args); end
 
   sig do
     params(
-      path: ::T.untyped,
-      options: ::T.untyped,
-      blk: ::T.untyped,
+      path: T.untyped,
+      options: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def path(path, options=T.unsafe(nil), &blk); end
 
   sig do
     params(
-      platforms: ::T.untyped,
+      platforms: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def platform(*platforms); end
 
   sig do
     params(
-      platforms: ::T.untyped,
+      platforms: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def platforms(*platforms); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def plugin(*args); end
 
   sig do
     params(
-      source: ::T.untyped,
-      args: ::T.untyped,
-      blk: ::T.untyped,
+      source: T.untyped,
+      args: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source(source, *args, &blk); end
 
   sig do
     params(
-      lockfile: ::T.untyped,
-      unlock: ::T.untyped,
+      lockfile: T.untyped,
+      unlock: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def to_definition(lockfile, unlock); end
 
   sig do
     params(
-      gemfile: ::T.untyped,
-      lockfile: ::T.untyped,
-      unlock: ::T.untyped,
+      gemfile: T.untyped,
+      lockfile: T.untyped,
+      unlock: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.evaluate(gemfile, lockfile, unlock); end
 end
 
 class Bundler::Dsl::DSLError < Bundler::GemfileError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backtrace(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def contents(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def description(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dsl_path(); end
 
   sig do
     params(
-      description: ::T.untyped,
-      dsl_path: ::T.untyped,
-      backtrace: ::T.untyped,
-      contents: ::T.untyped,
+      description: T.untyped,
+      dsl_path: T.untyped,
+      backtrace: T.untyped,
+      contents: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(description, dsl_path, backtrace, contents=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 end
 
 class Bundler::EndpointSpecification < Gem::Specification
-  ILLFORMED_MESSAGE = ::T.let(nil, ::T.untyped)
+  ILLFORMED_MESSAGE = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def __swap__(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def _local_specification(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bindir(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def checksum(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
+      dependencies: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies=(dependencies); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def executables(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def extensions(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def fetch_platform(); end
 
   sig do
     params(
-      name: ::T.untyped,
-      version: ::T.untyped,
-      platform: ::T.untyped,
-      dependencies: ::T.untyped,
-      metadata: ::T.untyped,
+      name: T.untyped,
+      version: T.untyped,
+      platform: T.untyped,
+      dependencies: T.untyped,
+      metadata: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, version, platform, dependencies, metadata=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def load_paths(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def post_install_message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote(); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remote=(remote); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def require_paths(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def required_ruby_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def required_rubygems_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def source(); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source=(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 end
 
 class Bundler::EnvironmentPreserver
-  BUNDLER_KEYS = ::T.let(nil, ::T.untyped)
-  BUNDLER_PREFIX = ::T.let(nil, ::T.untyped)
-  INTENTIONALLY_NIL = ::T.let(nil, ::T.untyped)
+  BUNDLER_KEYS = ::T.let(nil, T.untyped)
+  BUNDLER_PREFIX = ::T.let(nil, T.untyped)
+  INTENTIONALLY_NIL = ::T.let(nil, T.untyped)
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backup(); end
 
   sig do
     params(
-      env: ::T.untyped,
-      keys: ::T.untyped,
+      env: T.untyped,
+      keys: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(env, keys); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def restore(); end
 end
 
 class Bundler::FeatureFlag
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def allow_bundler_dependency_conflicts?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def allow_offline_install?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def auto_clean_without_path?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def auto_config_jobs?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_10_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_1_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_2_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_3_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_4_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_5_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_6_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_7_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_8_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def bundler_9_mode?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cache_all?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cache_command_is_package?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def console_command?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_cli_command(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_install_uses_path?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def deployment_means_frozen?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def disable_multisource?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def error_on_stderr?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def forget_cli_options?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def global_gem_cache?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def global_path_appends_ruby_scope?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def init_gems_rb?(); end
 
   sig do
     params(
-      bundler_version: ::T.untyped,
+      bundler_version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(bundler_version); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def list_command?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def lockfile_uses_separate_rubygems_sources?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def only_update_to_newer_versions?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path_relative_to_cwd?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def plugins?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def prefer_gems_rb?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def print_only_version_number?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def setup_makes_kernel_gem_public?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def skip_default_git_sources?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specific_platform?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def suppress_install_using_messages?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unlock_source_unlocks_spec?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def update_requires_all_flag?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def use_gem_version_promoter_for_major_updates?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def viz_command?(); end
 end
 
 module Bundler::FileUtils
   include ::Bundler::FileUtils::StreamUtils_
   extend ::Bundler::FileUtils::StreamUtils_
-  LOW_METHODS = ::T.let(nil, ::T.untyped)
-  METHODS = ::T.let(nil, ::T.untyped)
-  OPT_TABLE = ::T.let(nil, ::T.untyped)
+  LOW_METHODS = ::T.let(nil, T.untyped)
+  METHODS = ::T.let(nil, T.untyped)
+  OPT_TABLE = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      dir: ::T.untyped,
-      verbose: ::T.untyped,
-      block: ::T.untyped,
+      dir: T.untyped,
+      verbose: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cd(dir, verbose: T.unsafe(nil), &block); end
 
   sig do
     params(
-      dir: ::T.untyped,
-      verbose: ::T.untyped,
-      block: ::T.untyped,
+      dir: T.untyped,
+      verbose: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chdir(dir, verbose: T.unsafe(nil), &block); end
 
   sig do
     params(
-      mode: ::T.untyped,
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      mode: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      mode: ::T.untyped,
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      force: ::T.untyped,
+      mode: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod_R(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end
 
   sig do
     params(
-      user: ::T.untyped,
-      group: ::T.untyped,
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      user: T.untyped,
+      group: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      user: ::T.untyped,
-      group: ::T.untyped,
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      force: ::T.untyped,
+      user: T.untyped,
+      group: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown_R(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cmp(a, b); end
 
   sig do
     params(
-      opt: ::T.untyped,
+      opt: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.collect_method(opt); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.commands(); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_file(a, b); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_stream(a, b); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      dereference_root: ::T.untyped,
-      remove_destination: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference_root: T.untyped,
+      remove_destination: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      dereference: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_stream(src, dest); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      dereference_root: ::T.untyped,
-      remove_destination: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      dereference_root: T.untyped,
+      remove_destination: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp_r(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.getwd(); end
 
   sig do
     params(
-      mid: ::T.untyped,
-      opt: ::T.untyped,
+      mid: T.untyped,
+      opt: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.have_option?(mid, opt); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.identical?(a, b); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      mode: ::T.untyped,
-      owner: ::T.untyped,
-      group: ::T.untyped,
-      preserve: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      mode: T.untyped,
+      owner: T.untyped,
+      group: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.install(src, dest, mode: T.unsafe(nil), owner: T.unsafe(nil), group: T.unsafe(nil), preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.link(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_s(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_sf(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      mode: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.makedirs(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      mode: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      mode: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir_p(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      mode: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkpath(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      secure: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.move(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      secure: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mv(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.options(); end
 
   sig do
     params(
-      mid: ::T.untyped,
+      mid: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.options_of(mid); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.private_module_function(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.pwd(); end
 
   sig do
     params(
-      list: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_dir(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry_secure(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_file(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_f(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      secure: ::T.untyped,
+      list: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_r(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      secure: ::T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_rf(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      parents: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      parents: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmdir(list, parents: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      secure: ::T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmtree(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.safe_unlink(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      force: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.symlink(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
   sig do
     params(
-      list: ::T.untyped,
-      noop: ::T.untyped,
-      verbose: ::T.untyped,
-      mtime: ::T.untyped,
-      nocreate: ::T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      mtime: T.untyped,
+      nocreate: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.touch(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), mtime: T.unsafe(nil), nocreate: T.unsafe(nil)); end
 
   sig do
     params(
-      new: ::T.untyped,
-      old_list: ::T.untyped,
+      new: T.untyped,
+      old_list: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.uptodate?(new, old_list); end
 end
@@ -1993,526 +2026,526 @@ module Bundler::FileUtils::DryRun
   extend ::Bundler::FileUtils::StreamUtils_
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cd(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chdir(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod_R(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown_R(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cmp(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_file(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_stream(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_entry(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_file(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_stream(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp_r(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.getwd(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.identical?(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.install(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.link(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_s(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_sf(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.makedirs(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir_p(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkpath(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.move(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mv(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.pwd(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_dir(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry_secure(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_file(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_f(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_r(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_rf(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmtree(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.safe_unlink(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.symlink(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.touch(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.uptodate?(*_); end
 end
 
 class Bundler::FileUtils::Entry_
   include ::Bundler::FileUtils::StreamUtils_
-  DIRECTORY_TERM = ::T.let(nil, ::T.untyped)
-  SYSCASE = ::T.let(nil, ::T.untyped)
-  S_IF_DOOR = ::T.let(nil, ::T.untyped)
+  DIRECTORY_TERM = ::T.let(nil, T.untyped)
+  SYSCASE = ::T.let(nil, T.untyped)
+  S_IF_DOOR = ::T.let(nil, T.untyped)
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def blockdev?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def chardev?(); end
 
   sig do
     params(
-      mode: ::T.untyped,
+      mode: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def chmod(mode); end
 
   sig do
     params(
-      uid: ::T.untyped,
-      gid: ::T.untyped,
+      uid: T.untyped,
+      gid: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def chown(uid, gid); end
 
   sig do
     params(
-      dest: ::T.untyped,
+      dest: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def copy(dest); end
 
   sig do
     params(
-      dest: ::T.untyped,
+      dest: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def copy_file(dest); end
 
   sig do
     params(
-      path: ::T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def copy_metadata(path); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dereference?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def directory?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def door?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def entries(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def exist?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def file?(); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
-      deref: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
+      deref: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(a, b=T.unsafe(nil), deref=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def inspect(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def lstat(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def lstat!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def pipe?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform_support(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def postorder_traverse(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def prefix(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def preorder_traverse(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rel(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remove(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remove_dir1(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remove_file(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def socket?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def stat(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def stat!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def symlink?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def traverse(); end
 
   sig do
     params(
-      pre: ::T.untyped,
-      post: ::T.untyped,
+      pre: T.untyped,
+      post: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def wrap_traverse(pre, post); end
 end
@@ -2530,381 +2563,381 @@ module Bundler::FileUtils::NoWrite
   extend ::Bundler::FileUtils::StreamUtils_
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cd(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chdir(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod_R(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown_R(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cmp(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_file(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_stream(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_entry(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_file(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_stream(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp_r(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.getwd(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.identical?(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.install(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.link(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_s(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_sf(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.makedirs(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir_p(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkpath(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.move(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mv(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.pwd(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_dir(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry_secure(*_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_file(*_); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_f(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_r(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_rf(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmtree(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.safe_unlink(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.symlink(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.touch(*args, **options); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.uptodate?(*_); end
 end
@@ -2920,424 +2953,424 @@ module Bundler::FileUtils::Verbose
   extend ::Bundler::FileUtils::StreamUtils_
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cd(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chmod_R(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.chown_R(*args, **options); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cmp(a, b); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_file(a, b); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.compare_stream(a, b); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy(*args, **options); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      dereference_root: ::T.untyped,
-      remove_destination: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference_root: T.untyped,
+      remove_destination: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
-      preserve: ::T.untyped,
-      dereference: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end
 
   sig do
     params(
-      src: ::T.untyped,
-      dest: ::T.untyped,
+      src: T.untyped,
+      dest: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.copy_stream(src, dest); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cp_r(*args, **options); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.getwd(); end
 
   sig do
     params(
-      a: ::T.untyped,
-      b: ::T.untyped,
+      a: T.untyped,
+      b: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.identical?(a, b); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.install(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.link(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_s(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.ln_sf(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.makedirs(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkdir_p(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mkpath(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.move(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.mv(*args, **options); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.pwd(); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove(*args, **options); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_dir(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_entry_secure(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      path: ::T.untyped,
-      force: ::T.untyped,
+      path: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.remove_file(path, force=T.unsafe(nil)); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_f(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_r(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rm_rf(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmdir(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.rmtree(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.safe_unlink(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.symlink(*args, **options); end
 
   sig do
     params(
-      args: ::T.untyped,
-      options: ::T.untyped,
+      args: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.touch(*args, **options); end
 
   sig do
     params(
-      new: ::T.untyped,
-      old_list: ::T.untyped,
+      new: T.untyped,
+      old_list: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.uptodate?(new, old_list); end
 end
 
 module Bundler::GemHelpers
-  GENERICS = ::T.let(nil, ::T.untyped)
-  GENERIC_CACHE = ::T.let(nil, ::T.untyped)
+  GENERICS = ::T.let(nil, T.untyped)
+  GENERIC_CACHE = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      p: ::T.untyped,
+      p: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.generic(p); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.generic_local_platform(); end
 
   sig do
     params(
-      spec_platform: ::T.untyped,
-      user_platform: ::T.untyped,
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.platform_specificity_match(spec_platform, user_platform); end
 
   sig do
     params(
-      specs: ::T.untyped,
-      platform: ::T.untyped,
+      specs: T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.select_best_platform_match(specs, platform); end
 end
@@ -3346,121 +3379,121 @@ class Bundler::GemHelpers::PlatformMatch < Struct
   extend T::Generic
   Elem = type_member(fixed: T.untyped)
 
-  EXACT_MATCH = ::T.let(nil, ::T.untyped)
-  WORST_MATCH = ::T.let(nil, ::T.untyped)
+  EXACT_MATCH = ::T.let(nil, T.untyped)
+  WORST_MATCH = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def <=>(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cpu_match(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cpu_match=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def os_match(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def os_match=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform_version_match(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def platform_version_match=(_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
   sig do
     params(
-      spec_platform: ::T.untyped,
-      user_platform: ::T.untyped,
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.cpu_match(spec_platform, user_platform); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 
   sig do
     params(
-      spec_platform: ::T.untyped,
-      user_platform: ::T.untyped,
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.os_match(spec_platform, user_platform); end
 
   sig do
     params(
-      spec_platform: ::T.untyped,
-      user_platform: ::T.untyped,
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.platform_version_match(spec_platform, user_platform); end
 end
 
 class Bundler::GemNotFound < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::GemRequireError < Bundler::BundlerError
   sig do
     params(
-      orig_exception: ::T.untyped,
-      msg: ::T.untyped,
+      orig_exception: T.untyped,
+      msg: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(orig_exception, msg); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def orig_exception(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::GemfileError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
@@ -3468,217 +3501,235 @@ class Bundler::GemfileEvalError < Bundler::GemfileError
 end
 
 class Bundler::GemfileLockNotFound < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::GemfileNotFound < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::GemspecError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::GenericSystemCallError < Bundler::BundlerError
   sig do
     params(
-      underlying_error: ::T.untyped,
-      message: ::T.untyped,
+      underlying_error: T.untyped,
+      message: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(underlying_error, message); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def underlying_error(); end
 end
 
 class Bundler::GitError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::HTTPError < Bundler::BundlerError
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def filter_uri(uri); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
+class Bundler::Fetcher::AuthenticationRequiredError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::BadAuthenticationError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::CertificateFailureError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::FallbackError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::NetworkDownError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::SSLError < Bundler::HTTPError
+end
+
 class Bundler::Index
-  include ::Enumerable
-  EMPTY_SEARCH = ::T.let(nil, ::T.untyped)
-  NULL = ::T.let(nil, ::T.untyped)
-  RUBY = ::T.let(nil, ::T.untyped)
+  include T::Enumerable
+  EMPTY_SEARCH = ::T.let(nil, T.untyped)
+  NULL = ::T.let(nil, T.untyped)
+  RUBY = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def <<(spec); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
   sig do
     params(
-      query: ::T.untyped,
-      base: ::T.untyped,
+      query: T.untyped,
+      base: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def [](query, base=T.unsafe(nil)); end
 
   sig do
     params(
-      index: ::T.untyped,
+      index: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_source(index); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_specs(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      other_spec: ::T.untyped,
+      spec: T.untyped,
+      other_spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies_eql?(spec, other_spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependency_names(); end
 
   sig do
     params(
-      blk: ::T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def each(&blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def empty?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def inspect(); end
 
   sig do
     params(
-      query: ::T.untyped,
-      base: ::T.untyped,
+      query: T.untyped,
+      base: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def local_search(query, base=T.unsafe(nil)); end
 
   sig do
     params(
-      query: ::T.untyped,
-      base: ::T.untyped,
+      query: T.untyped,
+      base: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def search(query, base=T.unsafe(nil)); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def search_all(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def size(); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def sort_specs(specs); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def spec_names(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unmet_dependency_names(); end
 
   sig do
     params(
-      query: ::T.untyped,
-      base: ::T.untyped,
+      query: T.untyped,
+      base: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def unsorted_search(query, base); end
 
   sig do
     params(
-      other: ::T.untyped,
-      override_dupes: ::T.untyped,
+      other: T.untyped,
+      override_dupes: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def use(other, override_dupes=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.build(); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.sort_specs(specs); end
 end
 
 class Bundler::InstallError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::InstallHookError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::InvalidOption < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
@@ -3687,253 +3738,257 @@ class Bundler::LazySpecification
   include ::Bundler::GemHelpers
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def __materialize__(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def full_name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def git_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def identifier(); end
 
   sig do
     params(
-      name: ::T.untyped,
-      version: ::T.untyped,
-      platform: ::T.untyped,
-      source: ::T.untyped,
+      name: T.untyped,
+      version: T.untyped,
+      platform: T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, version, platform, source=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote(); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remote=(remote); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def respond_to?(*args); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def satisfies?(dependency); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def source(); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source=(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_lock(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 end
 
 class Bundler::LazySpecification::Identifier < Struct
   include ::Comparable
+  extend ::T::Generic
+
+  Elem = type_member(fixed: T.untyped)
+
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def <=>(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def platform=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform_string(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def source(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def version=(_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
 
 class Bundler::LockfileError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::LockfileParser
-  BUNDLED = ::T.let(nil, ::T.untyped)
-  DEPENDENCIES = ::T.let(nil, ::T.untyped)
-  ENVIRONMENT_VERSION_SECTIONS = ::T.let(nil, ::T.untyped)
-  GEM = ::T.let(nil, ::T.untyped)
-  GIT = ::T.let(nil, ::T.untyped)
-  KNOWN_SECTIONS = ::T.let(nil, ::T.untyped)
-  NAME_VERSION = ::T.let(nil, ::T.untyped)
-  OPTIONS = ::T.let(nil, ::T.untyped)
-  PATH = ::T.let(nil, ::T.untyped)
-  PLATFORMS = ::T.let(nil, ::T.untyped)
-  PLUGIN = ::T.let(nil, ::T.untyped)
-  RUBY = ::T.let(nil, ::T.untyped)
-  SECTIONS_BY_VERSION_INTRODUCED = ::T.let(nil, ::T.untyped)
-  SOURCE = ::T.let(nil, ::T.untyped)
-  SPECS = ::T.let(nil, ::T.untyped)
-  TYPES = ::T.let(nil, ::T.untyped)
-
-  sig {returns(::T.untyped)}
+  BUNDLED = ::T.let(nil, T.untyped)
+  DEPENDENCIES = ::T.let(nil, T.untyped)
+  ENVIRONMENT_VERSION_SECTIONS = ::T.let(nil, T.untyped)
+  GEM = ::T.let(nil, T.untyped)
+  GIT = ::T.let(nil, T.untyped)
+  KNOWN_SECTIONS = ::T.let(nil, T.untyped)
+  NAME_VERSION = ::T.let(nil, T.untyped)
+  OPTIONS = ::T.let(nil, T.untyped)
+  PATH = ::T.let(nil, T.untyped)
+  PLATFORMS = ::T.let(nil, T.untyped)
+  PLUGIN = ::T.let(nil, T.untyped)
+  RUBY = ::T.let(nil, T.untyped)
+  SECTIONS_BY_VERSION_INTRODUCED = ::T.let(nil, T.untyped)
+  SOURCE = ::T.let(nil, T.untyped)
+  SPECS = ::T.let(nil, T.untyped)
+  TYPES = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
   def bundler_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      lockfile: ::T.untyped,
+      lockfile: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(lockfile); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platforms(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def warn_for_outdated_bundler_version(); end
 
   sig do
     params(
-      lockfile_contents: ::T.untyped,
+      lockfile_contents: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.sections_in_lockfile(lockfile_contents); end
 
   sig do
     params(
-      base_version: ::T.untyped,
+      base_version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.sections_to_ignore(base_version=T.unsafe(nil)); end
 
   sig do
     params(
-      lockfile_contents: ::T.untyped,
+      lockfile_contents: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.unknown_sections_in_lockfile(lockfile_contents); end
 end
@@ -3945,36 +4000,36 @@ module Bundler::MatchPlatform
   include ::Bundler::GemHelpers
   sig do
     params(
-      p: ::T.untyped,
+      p: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def match_platform(p); end
 
   sig do
     params(
-      gemspec_platform: ::T.untyped,
-      local_platform: ::T.untyped,
+      gemspec_platform: T.untyped,
+      local_platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.platforms_match?(gemspec_platform, local_platform); end
 end
 
 module Bundler::Molinillo
-  VERSION = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, T.untyped)
 
 end
 
 class Bundler::Molinillo::CircularDependencyError < Bundler::Molinillo::ResolverError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      vertices: ::T.untyped,
+      vertices: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(vertices); end
 end
@@ -3982,10 +4037,10 @@ end
 module Bundler::Molinillo::Compatibility
   sig do
     params(
-      enum: ::T.untyped,
-      blk: ::T.untyped,
+      enum: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.flat_map(enum, &blk); end
 end
@@ -3994,235 +4049,235 @@ module Bundler::Molinillo::Delegates
 end
 
 module Bundler::Molinillo::Delegates::ResolutionState
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def activated(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def conflicts(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def depth(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def possibilities(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirements(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unused_unwind_options(); end
 end
 
 module Bundler::Molinillo::Delegates::SpecificationProvider
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def allow_missing?(dependency); end
 
   sig do
     params(
-      specification: ::T.untyped,
+      specification: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies_for(specification); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name_for(dependency); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name_for_explicit_dependency_source(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name_for_locking_dependency_source(); end
 
   sig do
     params(
-      requirement: ::T.untyped,
-      activated: ::T.untyped,
-      spec: ::T.untyped,
+      requirement: T.untyped,
+      activated: T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement_satisfied_by?(requirement, activated, spec); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def search_for(dependency); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
-      activated: ::T.untyped,
-      conflicts: ::T.untyped,
+      dependencies: T.untyped,
+      activated: T.untyped,
+      conflicts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def sort_dependencies(dependencies, activated, conflicts); end
 end
 
 class Bundler::Molinillo::DependencyGraph
   include ::TSort
-  include ::Enumerable
+  include T::Enumerable
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
   sig do
     params(
-      name: ::T.untyped,
-      payload: ::T.untyped,
-      parent_names: ::T.untyped,
-      requirement: ::T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
+      parent_names: T.untyped,
+      requirement: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_child_vertex(name, payload, parent_names, requirement); end
 
   sig do
     params(
-      origin: ::T.untyped,
-      destination: ::T.untyped,
-      requirement: ::T.untyped,
+      origin: T.untyped,
+      destination: T.untyped,
+      requirement: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_edge(origin, destination, requirement); end
 
   sig do
     params(
-      name: ::T.untyped,
-      payload: ::T.untyped,
-      root: ::T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
+      root: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_vertex(name, payload, root=T.unsafe(nil)); end
 
   sig do
     params(
-      edge: ::T.untyped,
+      edge: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def delete_edge(edge); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def detach_vertex_named(name); end
 
   sig do
     params(
-      blk: ::T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def each(&blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def inspect(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def log(); end
 
   sig do
     params(
-      tag: ::T.untyped,
+      tag: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def rewind_to(tag); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def root_vertex_named(name); end
 
   sig do
     params(
-      name: ::T.untyped,
-      payload: ::T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_payload(name, payload); end
 
   sig do
     params(
-      tag: ::T.untyped,
+      tag: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def tag(tag); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def to_dot(options=T.unsafe(nil)); end
 
   sig do
     params(
-      vertex: ::T.untyped,
-      block: ::T.untyped,
+      vertex: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def tsort_each_child(vertex, &block); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def tsort_each_node(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def vertex_named(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def vertices(); end
 
   sig do
     params(
-      vertices: ::T.untyped,
+      vertices: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.tsort(vertices); end
 end
@@ -4230,359 +4285,362 @@ end
 class Bundler::Molinillo::DependencyGraph::Action
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def next(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def next=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def previous(); end
 
   sig do
     params(
-      previous: ::T.untyped,
+      previous: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def previous=(previous); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular < Bundler::Molinillo::DependencyGraph::Action
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def destination(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(graph); end
 
   sig do
     params(
-      origin: ::T.untyped,
-      destination: ::T.untyped,
-      requirement: ::T.untyped,
+      origin: T.untyped,
+      destination: T.untyped,
+      requirement: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(origin, destination, requirement); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def make_edge(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def origin(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::AddVertex < Bundler::Molinillo::DependencyGraph::Action
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(graph); end
 
   sig do
     params(
-      name: ::T.untyped,
-      payload: ::T.untyped,
-      root: ::T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
+      root: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, payload, root); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def payload(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def root(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::DeleteEdge < Bundler::Molinillo::DependencyGraph::Action
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def destination_name(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(graph); end
 
   sig do
     params(
-      origin_name: ::T.untyped,
-      destination_name: ::T.untyped,
-      requirement: ::T.untyped,
+      origin_name: T.untyped,
+      destination_name: T.untyped,
+      requirement: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(origin_name, destination_name, requirement); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def make_edge(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def origin_name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::DetachVertexNamed < Bundler::Molinillo::DependencyGraph::Action
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(graph); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::Edge < Struct
-  sig {returns(::T.untyped)}
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
   def destination(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def destination=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def origin(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def origin=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement=(_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
 
 class Bundler::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
+  extend T::Enumerable
   sig do
     params(
-      graph: ::T.untyped,
-      origin: ::T.untyped,
-      destination: ::T.untyped,
-      requirement: ::T.untyped,
+      graph: T.untyped,
+      origin: T.untyped,
+      destination: T.untyped,
+      requirement: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_edge_no_circular(graph, origin, destination, requirement); end
 
   sig do
     params(
-      graph: ::T.untyped,
-      name: ::T.untyped,
-      payload: ::T.untyped,
-      root: ::T.untyped,
+      graph: T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
+      root: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_vertex(graph, name, payload, root); end
 
   sig do
     params(
-      graph: ::T.untyped,
-      origin_name: ::T.untyped,
-      destination_name: ::T.untyped,
-      requirement: ::T.untyped,
+      graph: T.untyped,
+      origin_name: T.untyped,
+      destination_name: T.untyped,
+      requirement: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def delete_edge(graph, origin_name, destination_name, requirement); end
 
   sig do
     params(
-      graph: ::T.untyped,
-      name: ::T.untyped,
+      graph: T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def detach_vertex_named(graph, name); end
 
   sig do
     params(
-      blk: ::T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def each(&blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def pop!(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def reverse_each(); end
 
   sig do
     params(
-      graph: ::T.untyped,
-      tag: ::T.untyped,
+      graph: T.untyped,
+      tag: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def rewind_to(graph, tag); end
 
   sig do
     params(
-      graph: ::T.untyped,
-      name: ::T.untyped,
-      payload: ::T.untyped,
+      graph: T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_payload(graph, name, payload); end
 
   sig do
     params(
-      graph: ::T.untyped,
-      tag: ::T.untyped,
+      graph: T.untyped,
+      tag: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def tag(graph, tag); end
 end
@@ -4590,381 +4648,389 @@ end
 class Bundler::Molinillo::DependencyGraph::SetPayload < Bundler::Molinillo::DependencyGraph::Action
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(graph); end
 
   sig do
     params(
-      name: ::T.untyped,
-      payload: ::T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, payload); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def payload(); end
 
   sig do
     params(
-      graph: ::T.untyped,
+      graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::Tag < Bundler::Molinillo::DependencyGraph::Action
   sig do
     params(
-      _graph: ::T.untyped,
+      _graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def down(_graph); end
 
   sig do
     params(
-      tag: ::T.untyped,
+      tag: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(tag); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def tag(); end
 
   sig do
     params(
-      _graph: ::T.untyped,
+      _graph: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def up(_graph); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.action_name(); end
 end
 
 class Bundler::Molinillo::DependencyGraph::Vertex
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
   sig do
     params(
-      other: ::T.untyped,
-      visited: ::T.untyped,
+      other: T.untyped,
+      visited: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def _path_to?(other, visited=T.unsafe(nil)); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ancestor?(other); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def descendent?(other); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def explicit_requirements(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def incoming_edges(); end
 
   sig do
     params(
-      incoming_edges: ::T.untyped,
+      incoming_edges: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def incoming_edges=(incoming_edges); end
 
   sig do
     params(
-      name: ::T.untyped,
-      payload: ::T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, payload); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def inspect(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def is_reachable_from?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name=(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def outgoing_edges(); end
 
   sig do
     params(
-      outgoing_edges: ::T.untyped,
+      outgoing_edges: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def outgoing_edges=(outgoing_edges); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def path_to?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def payload(); end
 
   sig do
     params(
-      payload: ::T.untyped,
+      payload: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def payload=(payload); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def predecessors(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def recursive_predecessors(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def recursive_successors(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirements(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def root(); end
 
   sig do
     params(
-      root: ::T.untyped,
+      root: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def root=(root); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def root?(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def shallow_eql?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def successors(); end
 end
 
 class Bundler::Molinillo::DependencyState < Bundler::Molinillo::ResolutionState
-  sig {returns(::T.untyped)}
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
   def pop_possibility_state(); end
 end
 
 class Bundler::Molinillo::NoSuchDependencyError < Bundler::Molinillo::ResolverError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependency(); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependency=(dependency); end
 
   sig do
     params(
-      dependency: ::T.untyped,
-      required_by: ::T.untyped,
+      dependency: T.untyped,
+      required_by: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(dependency, required_by=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def required_by(); end
 
   sig do
     params(
-      required_by: ::T.untyped,
+      required_by: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def required_by=(required_by); end
 end
 
 class Bundler::Molinillo::PossibilityState < Bundler::Molinillo::ResolutionState
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
 end
 
 class Bundler::Molinillo::ResolutionState < Struct
-  sig {returns(::T.untyped)}
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
   def activated(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def activated=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def conflicts(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def conflicts=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def depth(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def depth=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def possibilities(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def possibilities=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirements(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirements=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unused_unwind_options(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def unused_unwind_options=(_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.empty(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
@@ -4972,348 +5038,357 @@ end
 class Bundler::Molinillo::Resolver
   sig do
     params(
-      specification_provider: ::T.untyped,
-      resolver_ui: ::T.untyped,
+      specification_provider: T.untyped,
+      resolver_ui: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(specification_provider, resolver_ui); end
 
   sig do
     params(
-      requested: ::T.untyped,
-      base: ::T.untyped,
+      requested: T.untyped,
+      base: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def resolve(requested, base=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def resolver_ui(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specification_provider(); end
 end
 
 class Bundler::Molinillo::Resolver::Resolution
   include ::Bundler::Molinillo::Delegates::SpecificationProvider
   include ::Bundler::Molinillo::Delegates::ResolutionState
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def base(); end
 
   sig do
     params(
-      specification_provider: ::T.untyped,
-      resolver_ui: ::T.untyped,
-      requested: ::T.untyped,
-      base: ::T.untyped,
+      specification_provider: T.untyped,
+      resolver_ui: T.untyped,
+      requested: T.untyped,
+      base: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(specification_provider, resolver_ui, requested, base); end
 
   sig do
     params(
-      iteration_rate: ::T.untyped,
+      iteration_rate: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def iteration_rate=(iteration_rate); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def original_requested(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def resolve(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def resolver_ui(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specification_provider(); end
 
   sig do
     params(
-      started_at: ::T.untyped,
+      started_at: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def started_at=(started_at); end
 
   sig do
     params(
-      states: ::T.untyped,
+      states: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def states=(states); end
 end
 
 class Bundler::Molinillo::Resolver::Resolution::Conflict < Struct
-  sig {returns(::T.untyped)}
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
   def activated_by_name(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def activated_by_name=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def existing(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def existing=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def locked_requirement(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def locked_requirement=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def possibility(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def possibility_set(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def possibility_set=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement_trees(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement_trees=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirements(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirements=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def underlying_error(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def underlying_error=(_); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
 
 class Bundler::Molinillo::Resolver::Resolution::PossibilitySet < Struct
-  sig {returns(::T.untyped)}
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def latest_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def possibilities(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def possibilities=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
 
 class Bundler::Molinillo::Resolver::Resolution::UnwindDetails < Struct
   include ::Comparable
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def <=>(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_requirements(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def conflicting_requirements(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def conflicting_requirements=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement_tree(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement_tree=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirement_trees(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement_trees=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requirements_unwound_to_instead(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirements_unwound_to_instead=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def reversed_requirement_tree_index(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def state_index(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def state_index=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def state_requirement(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def state_requirement=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def sub_dependencies_to_avoid(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unwinding_to_primary_requirement?(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
@@ -5324,334 +5399,387 @@ end
 module Bundler::Molinillo::SpecificationProvider
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def allow_missing?(dependency); end
 
   sig do
     params(
-      specification: ::T.untyped,
+      specification: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies_for(specification); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name_for(dependency); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name_for_explicit_dependency_source(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name_for_locking_dependency_source(); end
 
   sig do
     params(
-      requirement: ::T.untyped,
-      activated: ::T.untyped,
-      spec: ::T.untyped,
+      requirement: T.untyped,
+      activated: T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement_satisfied_by?(requirement, activated, spec); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def search_for(dependency); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
-      activated: ::T.untyped,
-      conflicts: ::T.untyped,
+      dependencies: T.untyped,
+      activated: T.untyped,
+      conflicts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def sort_dependencies(dependencies, activated, conflicts); end
 end
 
 module Bundler::Molinillo::UI
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def after_resolution(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def before_resolution(); end
 
   sig do
     params(
-      depth: ::T.untyped,
+      depth: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def debug(depth=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def debug?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def indicate_progress(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def output(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def progress_rate(); end
 end
 
 class Bundler::Molinillo::VersionConflict < Bundler::Molinillo::ResolverError
   include ::Bundler::Molinillo::Delegates::SpecificationProvider
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def conflicts(); end
 
   sig do
     params(
-      conflicts: ::T.untyped,
-      specification_provider: ::T.untyped,
+      conflicts: T.untyped,
+      specification_provider: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(conflicts, specification_provider); end
 
   sig do
     params(
-      opts: ::T.untyped,
+      opts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def message_with_trees(opts=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specification_provider(); end
 end
 
 class Bundler::NoSpaceOnDeviceError < Bundler::PermissionError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::OperationNotSupportedError < Bundler::PermissionError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::PathError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::PermissionError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def action(); end
 
   sig do
     params(
-      path: ::T.untyped,
-      permission_type: ::T.untyped,
+      path: T.untyped,
+      permission_type: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(path, permission_type=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 module Bundler::Plugin
-  PLUGIN_FILE_NAME = ::T.let(nil, ::T.untyped)
+  PLUGIN_FILE_NAME = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      command: ::T.untyped,
-      cls: ::T.untyped,
+      command: T.untyped,
+      cls: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.add_command(command, cls); end
 
   sig do
     params(
-      event: ::T.untyped,
-      block: ::T.untyped,
+      event: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.add_hook(event, &block); end
 
   sig do
     params(
-      source: ::T.untyped,
-      cls: ::T.untyped,
+      source: T.untyped,
+      cls: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.add_source(source, cls); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.cache(); end
 
   sig do
     params(
-      command: ::T.untyped,
+      command: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.command?(command); end
 
   sig do
     params(
-      command: ::T.untyped,
-      args: ::T.untyped,
+      command: T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.exec_command(command, args); end
 
   sig do
     params(
-      gemfile: ::T.untyped,
-      inline: ::T.untyped,
+      gemfile: T.untyped,
+      inline: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.gemfile_install(gemfile=T.unsafe(nil), &inline); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.global_root(); end
 
   sig do
     params(
-      event: ::T.untyped,
-      args: ::T.untyped,
-      arg_blk: ::T.untyped,
+      event: T.untyped,
+      args: T.untyped,
+      arg_blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.hook(event, *args, &arg_blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.index(); end
 
   sig do
     params(
-      names: ::T.untyped,
-      options: ::T.untyped,
+      names: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.install(names, options); end
 
   sig do
     params(
-      plugin: ::T.untyped,
+      plugin: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.installed?(plugin); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.local_root(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.reset!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.root(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.source(name); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.source?(name); end
 
   sig do
     params(
-      locked_opts: ::T.untyped,
+      locked_opts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.source_from_lock(locked_opts); end
 end
 
 class Bundler::Plugin::API
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cache_dir(); end
 
   sig do
     params(
-      name: ::T.untyped,
-      args: ::T.untyped,
-      blk: ::T.untyped,
+      name: T.untyped,
+      args: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def method_missing(name, *args, &blk); end
 
   sig do
     params(
-      names: ::T.untyped,
+      names: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def tmp(*names); end
 
   sig do
     params(
-      command: ::T.untyped,
-      cls: ::T.untyped,
+      command: T.untyped,
+      cls: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.command(command, cls=T.unsafe(nil)); end
 
   sig do
     params(
-      event: ::T.untyped,
-      block: ::T.untyped,
+      event: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.hook(event, &block); end
 
   sig do
     params(
-      source: ::T.untyped,
-      cls: ::T.untyped,
+      source: T.untyped,
+      cls: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.source(source, cls=T.unsafe(nil)); end
 end
 
+class Bundler::Plugin::DSL
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped
+    )
+    .returns(T.untyped)
+  end
+  def _gem(name, *args); end
+
+  sig { returns(T.untyped) }
+  def inferred_plugins(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped
+    )
+    .returns(T.untyped)
+  end
+  def plugin(name, *args); end
+end
+
+module Bundler::Plugin::Events
+  def self.defined_event?(event); end
+end
+
+class Bundler::Plugin::Index
+  def command_plugin(command); end
+
+  def commands(); end
+
+  def global_index_file(); end
+
+  def hook_plugins(event); end
+
+  def index_file(); end
+
+  def installed?(name); end
+
+  def load_paths(name); end
+
+  def local_index_file(); end
+
+  def plugin_path(name); end
+
+  def register_plugin(name, path, load_paths, commands, sources, hooks); end
+
+  def source?(source); end
+
+  def source_plugin(name); end
+end
+
 class Bundler::Plugin::MalformattedPlugin < Bundler::PluginError
 end
 
@@ -5661,13 +5789,16 @@ end
 class Bundler::Plugin::UnknownSourceError < Bundler::PluginError
 end
 
+class Bundler::Plugin::DSL::PluginGemfileError < Bundler::PluginError
+end
+
 class Bundler::PluginError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::ProductionError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
@@ -5677,235 +5808,235 @@ class Bundler::RemoteSpecification
   include ::Bundler::GemHelpers
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def <=>(other); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def __swap__(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
+      dependencies: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies=(dependencies); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def fetch_platform(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def full_name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def git_version(); end
 
   sig do
     params(
-      name: ::T.untyped,
-      version: ::T.untyped,
-      platform: ::T.untyped,
-      spec_fetcher: ::T.untyped,
+      name: T.untyped,
+      version: T.untyped,
+      platform: T.untyped,
+      spec_fetcher: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(name, version, platform, spec_fetcher); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platform(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote(); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remote=(remote); end
 
   sig do
     params(
-      method: ::T.untyped,
-      include_all: ::T.untyped,
+      method: T.untyped,
+      include_all: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def respond_to?(method, include_all=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def sort_obj(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def source(); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source=(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 end
 
 class Bundler::Resolver
   include ::Bundler::Molinillo::SpecificationProvider
   include ::Bundler::Molinillo::UI
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def after_resolution(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def before_resolution(); end
 
   sig do
     params(
-      depth: ::T.untyped,
+      depth: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def debug(depth=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def debug?(); end
 
   sig do
     params(
-      specification: ::T.untyped,
+      specification: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependencies_for(specification); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def index_for(dependency); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def indicate_progress(); end
 
   sig do
     params(
-      index: ::T.untyped,
-      source_requirements: ::T.untyped,
-      base: ::T.untyped,
-      gem_version_promoter: ::T.untyped,
-      additional_base_requirements: ::T.untyped,
-      platforms: ::T.untyped,
+      index: T.untyped,
+      source_requirements: T.untyped,
+      base: T.untyped,
+      gem_version_promoter: T.untyped,
+      additional_base_requirements: T.untyped,
+      platforms: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name_for(dependency); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name_for_explicit_dependency_source(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name_for_locking_dependency_source(); end
 
   sig do
     params(
-      vertex: ::T.untyped,
+      vertex: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def relevant_sources_for_vertex(vertex); end
 
   sig do
     params(
-      requirement: ::T.untyped,
-      activated: ::T.untyped,
-      spec: ::T.untyped,
+      requirement: T.untyped,
+      activated: T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def requirement_satisfied_by?(requirement, activated, spec); end
 
   sig do
     params(
-      dependency: ::T.untyped,
+      dependency: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def search_for(dependency); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
-      activated: ::T.untyped,
-      conflicts: ::T.untyped,
+      dependencies: T.untyped,
+      activated: T.untyped,
+      conflicts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def sort_dependencies(dependencies, activated, conflicts); end
 
   sig do
     params(
-      requirements: ::T.untyped,
+      requirements: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def start(requirements); end
 
   sig do
     params(
-      platform: ::T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.platform_sort_key(platform); end
 
   sig do
     params(
-      requirements: ::T.untyped,
-      index: ::T.untyped,
-      source_requirements: ::T.untyped,
-      base: ::T.untyped,
-      gem_version_promoter: ::T.untyped,
-      additional_base_requirements: ::T.untyped,
-      platforms: ::T.untyped,
+      requirements: T.untyped,
+      index: T.untyped,
+      source_requirements: T.untyped,
+      base: T.untyped,
+      gem_version_promoter: T.untyped,
+      additional_base_requirements: T.untyped,
+      platforms: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.resolve(requirements, index, source_requirements=T.unsafe(nil), base=T.unsafe(nil), gem_version_promoter=T.unsafe(nil), additional_base_requirements=T.unsafe(nil), platforms=T.unsafe(nil)); end
 
   sig do
     params(
-      platforms: ::T.untyped,
+      platforms: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.sort_platforms(platforms); end
 end
@@ -5914,97 +6045,97 @@ class Bundler::Resolver::SpecGroup
   include ::Bundler::GemHelpers
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
   sig do
     params(
-      platform: ::T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def activate_platform!(platform); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies_for_activated_platforms(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
   sig do
     params(
-      platform: ::T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def for?(platform); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ignores_bundler_dependencies(); end
 
   sig do
     params(
-      ignores_bundler_dependencies: ::T.untyped,
+      ignores_bundler_dependencies: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ignores_bundler_dependencies=(ignores_bundler_dependencies); end
 
   sig do
     params(
-      all_specs: ::T.untyped,
+      all_specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(all_specs); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name=(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def source(); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source=(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 
   sig do
     params(
-      version: ::T.untyped,
+      version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def version=(version); end
 end
@@ -6012,704 +6143,704 @@ end
 module Bundler::RubyDsl
   sig do
     params(
-      ruby_version: ::T.untyped,
+      ruby_version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ruby(*ruby_version); end
 end
 
 class Bundler::RubyVersion
-  PATTERN = ::T.let(nil, ::T.untyped)
+  PATTERN = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def diff(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def engine(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def engine_gem_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def engine_versions(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def exact?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_version(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def host(); end
 
   sig do
     params(
-      versions: ::T.untyped,
-      patchlevel: ::T.untyped,
-      engine: ::T.untyped,
-      engine_version: ::T.untyped,
+      versions: T.untyped,
+      patchlevel: T.untyped,
+      engine: T.untyped,
+      engine_version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(versions, patchlevel, engine, engine_version); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def patchlevel(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def single_version_string(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_gem_version_with_patchlevel(); end
 
   sig do
     params(
-      versions: ::T.untyped,
+      versions: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def to_s(versions=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def versions(); end
 
   sig do
     params(
-      versions: ::T.untyped,
+      versions: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def versions_string(versions); end
 
   sig do
     params(
-      string: ::T.untyped,
+      string: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.from_string(string); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.system(); end
 end
 
 class Bundler::RubyVersionMismatch < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::RubygemsIntegration
-  EXT_LOCK = ::T.let(nil, ::T.untyped)
+  EXT_LOCK = ::T.let(nil, T.untyped)
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backport_base_dir(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backport_cache_file(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backport_segment_generation(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backport_spec_file(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backport_yaml_initialize(); end
 
   sig do
     params(
-      gem: ::T.untyped,
-      bin: ::T.untyped,
-      ver: ::T.untyped,
+      gem: T.untyped,
+      bin: T.untyped,
+      ver: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def bin_path(gem, bin, ver); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def binstubs_call_gem?(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      skip_validation: ::T.untyped,
+      spec: T.untyped,
+      skip_validation: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def build(spec, skip_validation=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def build_args(); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def build_args=(args); end
 
   sig do
     params(
-      gem_dir: ::T.untyped,
-      spec: ::T.untyped,
+      gem_dir: T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def build_gem(gem_dir, spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def clear_paths(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def config_map(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def configuration(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      uri: ::T.untyped,
-      path: ::T.untyped,
+      spec: T.untyped,
+      uri: T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def download_gem(spec, uri, path); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ext_lock(); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def fetch_all_remote_specs(remote); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def fetch_prerelease_specs(); end
 
   sig do
     params(
-      all: ::T.untyped,
-      pre: ::T.untyped,
-      blk: ::T.untyped,
+      all: T.untyped,
+      pre: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def fetch_specs(all, pre, &blk); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_bindir(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_cache(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_dir(); end
 
   sig do
     params(
-      path: ::T.untyped,
-      policy: ::T.untyped,
+      path: T.untyped,
+      policy: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def gem_from_path(path, policy=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_path(); end
 
   sig do
     params(
-      obj: ::T.untyped,
+      obj: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def inflate(obj); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install_with_build_args(args); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def load_path_insert_index(); end
 
   sig do
     params(
-      files: ::T.untyped,
+      files: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def load_plugin_files(files); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def load_plugins(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def loaded_gem_paths(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def loaded_specs(name); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def mark_loaded(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def marshal_spec_dir(); end
 
   sig do
     params(
-      klass: ::T.untyped,
-      method: ::T.untyped,
+      klass: T.untyped,
+      method: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def method_visibility(klass, method); end
 
   sig do
     params(
-      obj: ::T.untyped,
+      obj: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def path(obj); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path_separator(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def platforms(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def post_reset_hooks(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def preserve_paths(); end
 
   sig do
     params(
-      req_str: ::T.untyped,
+      req_str: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def provides?(req_str); end
 
   sig do
     params(
-      path: ::T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def read_binary(path); end
 
   sig do
     params(
-      klass: ::T.untyped,
-      method: ::T.untyped,
-      unbound_method: ::T.untyped,
-      block: ::T.untyped,
+      klass: T.untyped,
+      method: T.untyped,
+      unbound_method: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def redefine_method(klass, method, unbound_method=T.unsafe(nil), &block); end
 
   sig do
     params(
-      specs: ::T.untyped,
-      specs_by_name: ::T.untyped,
+      specs: T.untyped,
+      specs_by_name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def replace_bin_path(specs, specs_by_name); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def replace_entrypoints(specs); end
 
   sig do
     params(
-      specs: ::T.untyped,
-      specs_by_name: ::T.untyped,
+      specs: T.untyped,
+      specs_by_name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def replace_gem(specs, specs_by_name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def replace_refresh(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def repository_subdirectories(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def reset(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def reverse_rubygems_kernel_mixin(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ruby_engine(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def security_policies(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def security_policy_keys(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      installed_by_version: ::T.untyped,
+      spec: T.untyped,
+      installed_by_version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_installed_by_version(spec, installed_by_version=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def sources(); end
 
   sig do
     params(
-      val: ::T.untyped,
+      val: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def sources=(val); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def spec_cache_dirs(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def spec_default_gem?(spec); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def spec_extension_dir(spec); end
 
   sig do
     params(
-      path: ::T.untyped,
-      policy: ::T.untyped,
+      path: T.untyped,
+      policy: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def spec_from_gem(path, policy=T.unsafe(nil)); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      glob: ::T.untyped,
+      spec: T.untyped,
+      glob: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def spec_matches_for_glob(spec, glob); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      default: ::T.untyped,
+      spec: T.untyped,
+      default: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def spec_missing_extensions?(spec, default=T.unsafe(nil)); end
 
   sig do
     params(
-      stub: ::T.untyped,
-      spec: ::T.untyped,
+      stub: T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub_set_spec(stub, spec); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub_source_index(specs); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def stubs_provide_full_functionality?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def suffix_pattern(); end
 
   sig do
     params(
-      obj: ::T.untyped,
+      obj: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ui=(obj); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def undo_replacements(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def user_home(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def validate(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def with_build_args(args); end
 
   sig do
     params(
-      req_str: ::T.untyped,
+      req_str: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.provides?(req_str); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.version(); end
 end
 
 class Bundler::RubygemsIntegration::AlmostModern < Bundler::RubygemsIntegration::Modern
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def preserve_paths(); end
 end
 
 class Bundler::RubygemsIntegration::Ancient < Bundler::RubygemsIntegration::Legacy
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 end
 
 class Bundler::RubygemsIntegration::Future < Bundler::RubygemsIntegration
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_specs(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      skip_validation: ::T.untyped,
+      spec: T.untyped,
+      skip_validation: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def build(spec, skip_validation=T.unsafe(nil)); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      uri: ::T.untyped,
-      path: ::T.untyped,
+      spec: T.untyped,
+      uri: T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def download_gem(spec, uri, path); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def fetch_all_remote_specs(remote); end
 
   sig do
     params(
-      source: ::T.untyped,
-      remote: ::T.untyped,
-      name: ::T.untyped,
+      source: T.untyped,
+      remote: T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def fetch_specs(source, remote, name); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_name(name); end
 
   sig do
     params(
-      path: ::T.untyped,
-      policy: ::T.untyped,
+      path: T.untyped,
+      policy: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def gem_from_path(path, policy=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_remote_fetcher(); end
 
   sig do
     params(
-      args: ::T.untyped,
+      args: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install_with_build_args(args); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path_separator(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def repository_subdirectories(); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub_rubygems(specs); end
 end
 
 class Bundler::RubygemsIntegration::Legacy < Bundler::RubygemsIntegration
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_specs(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_name(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def post_reset_hooks(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def reset(); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub_rubygems(specs); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def validate(spec); end
 end
 
 class Bundler::RubygemsIntegration::Modern < Bundler::RubygemsIntegration
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_specs(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_name(name); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub_rubygems(specs); end
 end
 
 class Bundler::RubygemsIntegration::MoreFuture < Bundler::RubygemsIntegration::Future
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def backport_ext_builder_monitor(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def binstubs_call_gem?(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_name(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def stubs_provide_full_functionality?(); end
 
   sig do
     params(
-      gemfile: ::T.untyped,
+      gemfile: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def use_gemdeps(gemfile); end
 end
@@ -6717,10 +6848,10 @@ end
 class Bundler::RubygemsIntegration::MoreModern < Bundler::RubygemsIntegration::Modern
   sig do
     params(
-      spec: ::T.untyped,
-      skip_validation: ::T.untyped,
+      spec: T.untyped,
+      skip_validation: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def build(spec, skip_validation=T.unsafe(nil)); end
 end
@@ -6728,324 +6859,327 @@ end
 class Bundler::RubygemsIntegration::Transitional < Bundler::RubygemsIntegration::Legacy
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub_rubygems(specs); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def validate(spec); end
 end
 
 class Bundler::Runtime
   include ::Bundler::SharedHelpers
-  REQUIRE_ERRORS = ::T.let(nil, ::T.untyped)
+  REQUIRE_ERRORS = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      custom_path: ::T.untyped,
+      custom_path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cache(custom_path=T.unsafe(nil)); end
 
   sig do
     params(
-      dry_run: ::T.untyped,
+      dry_run: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def clean(dry_run=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def current_dependencies(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependencies(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gems(); end
 
   sig do
     params(
-      root: ::T.untyped,
-      definition: ::T.untyped,
+      root: T.untyped,
+      definition: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(root, definition); end
 
   sig do
     params(
-      opts: ::T.untyped,
+      opts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def lock(opts=T.unsafe(nil)); end
 
   sig do
     params(
-      cache_path: ::T.untyped,
+      cache_path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def prune_cache(cache_path); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requested_specs(); end
 
   sig do
     params(
-      groups: ::T.untyped,
+      groups: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def require(*groups); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requires(); end
 
   sig do
     params(
-      groups: ::T.untyped,
+      groups: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def setup(*groups); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 end
 
 class Bundler::SecurityError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::Settings
-  ARRAY_KEYS = ::T.let(nil, ::T.untyped)
-  BOOL_KEYS = ::T.let(nil, ::T.untyped)
-  CONFIG_REGEX = ::T.let(nil, ::T.untyped)
-  DEFAULT_CONFIG = ::T.let(nil, ::T.untyped)
-  NORMALIZE_URI_OPTIONS_PATTERN = ::T.let(nil, ::T.untyped)
-  NUMBER_KEYS = ::T.let(nil, ::T.untyped)
-  PER_URI_OPTIONS = ::T.let(nil, ::T.untyped)
+  ARRAY_KEYS = ::T.let(nil, T.untyped)
+  BOOL_KEYS = ::T.let(nil, T.untyped)
+  CONFIG_REGEX = ::T.let(nil, T.untyped)
+  DEFAULT_CONFIG = ::T.let(nil, T.untyped)
+  NORMALIZE_URI_OPTIONS_PATTERN = ::T.let(nil, T.untyped)
+  NUMBER_KEYS = ::T.let(nil, T.untyped)
+  PER_URI_OPTIONS = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def [](name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def allow_sudo?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def app_cache_path(); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def credentials_for(uri); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gem_mirrors(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ignore_config?(); end
 
   sig do
     params(
-      root: ::T.untyped,
+      root: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(root=T.unsafe(nil)); end
 
   sig do
     params(
-      key: ::T.untyped,
+      key: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def key_for(key); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def local_overrides(); end
 
   sig do
     params(
-      key: ::T.untyped,
+      key: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def locations(key); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def mirror_for(uri); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path(); end
 
   sig do
     params(
-      exposed_key: ::T.untyped,
+      exposed_key: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def pretty_values_for(exposed_key); end
 
   sig do
     params(
-      key: ::T.untyped,
-      value: ::T.untyped,
+      key: T.untyped,
+      value: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_command_option(key, value); end
 
   sig do
     params(
-      key: ::T.untyped,
-      value: ::T.untyped,
+      key: T.untyped,
+      value: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_command_option_if_given(key, value); end
 
   sig do
     params(
-      key: ::T.untyped,
-      value: ::T.untyped,
+      key: T.untyped,
+      value: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_global(key, value); end
 
   sig do
     params(
-      key: ::T.untyped,
-      value: ::T.untyped,
+      key: T.untyped,
+      value: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_local(key, value); end
 
   sig do
     params(
-      update: ::T.untyped,
+      update: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def temporary(update); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def validate!(); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.normalize_uri(uri); end
 end
 
 class Bundler::Settings::Path < Struct
-  sig {returns(::T.untyped)}
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
   def append_ruby_scope(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def append_ruby_scope=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def base_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def base_path_relative_to_pwd(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_install_uses_path(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def default_install_uses_path=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def explicit_path(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def explicit_path=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def system_path(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def system_path=(_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def use_system_gems?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def validate!(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.[](*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def self.members(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.new(*_); end
 end
@@ -7054,128 +7188,128 @@ module Bundler::SharedHelpers
   extend ::Bundler::SharedHelpers
   sig do
     params(
-      dir: ::T.untyped,
-      blk: ::T.untyped,
+      dir: T.untyped,
+      blk: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def chdir(dir, &blk); end
 
   sig do
     params(
-      constant_name: ::T.untyped,
-      namespace: ::T.untyped,
+      constant_name: T.untyped,
+      namespace: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def const_get_safely(constant_name, namespace); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_bundle_dir(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_gemfile(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_lockfile(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def digest(name); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      old_deps: ::T.untyped,
-      new_deps: ::T.untyped,
+      spec: T.untyped,
+      old_deps: T.untyped,
+      new_deps: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ensure_same_dependencies(spec, old_deps, new_deps); end
 
   sig do
     params(
-      path: ::T.untyped,
-      action: ::T.untyped,
-      block: ::T.untyped,
+      path: T.untyped,
+      action: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def filesystem_access(path, action=T.unsafe(nil), &block); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def in_bundle?(); end
 
   sig do
     params(
-      major_version: ::T.untyped,
-      message: ::T.untyped,
+      major_version: T.untyped,
+      message: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def major_deprecation(major_version, message); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def md5_available?(); end
 
   sig do
     params(
-      dep: ::T.untyped,
-      print_source: ::T.untyped,
+      dep: T.untyped,
+      print_source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def pretty_dependency(dep, print_source=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def print_major_deprecations!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def pwd(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def root(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def set_bundle_environment(); end
 
   sig do
     params(
-      key: ::T.untyped,
-      value: ::T.untyped,
+      key: T.untyped,
+      value: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def set_env(key, value); end
 
   sig do
     params(
-      signal: ::T.untyped,
-      override: ::T.untyped,
-      block: ::T.untyped,
+      signal: T.untyped,
+      override: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def trap(signal, override=T.unsafe(nil), &block); end
 
   sig do
     params(
-      block: ::T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def with_clean_git_env(&block); end
 
   sig do
     params(
-      gemfile_path: ::T.untyped,
-      contents: ::T.untyped,
+      gemfile_path: T.untyped,
+      contents: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def write_to_gemfile(gemfile_path, contents); end
 end
@@ -7183,80 +7317,80 @@ end
 class Bundler::Source
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def can_lock?(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependency_names(); end
 
   sig do
     params(
-      dependency_names: ::T.untyped,
+      dependency_names: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def dependency_names=(dependency_names); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependency_names_to_double_check(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def double_check_for(*_); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def extension_cache_path(spec); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def include?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def inspect(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unmet_deps(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def version_message(spec); end
 end
 
 class Bundler::Source::Gemspec < Bundler::Source::Path
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def as_path_source(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def gemspec(); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(options); end
 end
@@ -7264,121 +7398,121 @@ end
 class Bundler::Source::Git < Bundler::Source::Path
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def allow_git_ops?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def app_cache_dirname(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def branch(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      custom_path: ::T.untyped,
+      spec: T.untyped,
+      custom_path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cache(spec, custom_path=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cache_path(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def extension_dir_name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(options); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      options: ::T.untyped,
+      spec: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install(spec, options=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def install_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def load_spec_files(); end
 
   sig do
     params(
-      path: ::T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def local_override!(path); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def options(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ref(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def revision(); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def specs(*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def submodules(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_lock(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unlock!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def uri(); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.from_lock(options); end
 end
@@ -7386,11 +7520,11 @@ end
 class Bundler::Source::Git::GitCommandError < Bundler::GitError
   sig do
     params(
-      command: ::T.untyped,
-      path: ::T.untyped,
-      extra_info: ::T.untyped,
+      command: T.untyped,
+      path: T.untyped,
+      extra_info: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(command, path=T.unsafe(nil), extra_info=T.unsafe(nil)); end
 end
@@ -7398,112 +7532,112 @@ end
 class Bundler::Source::Git::GitNotAllowedError < Bundler::GitError
   sig do
     params(
-      command: ::T.untyped,
+      command: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(command); end
 end
 
 class Bundler::Source::Git::GitNotInstalledError < Bundler::GitError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 end
 
 class Bundler::Source::Git::GitProxy
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def branch(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def checkout(); end
 
   sig do
     params(
-      commit: ::T.untyped,
+      commit: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def contains?(commit); end
 
   sig do
     params(
-      destination: ::T.untyped,
-      submodules: ::T.untyped,
+      destination: T.untyped,
+      submodules: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def copy_to(destination, submodules=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def full_version(); end
 
   sig do
     params(
-      path: ::T.untyped,
-      uri: ::T.untyped,
-      ref: ::T.untyped,
-      revision: ::T.untyped,
-      git: ::T.untyped,
+      path: T.untyped,
+      uri: T.untyped,
+      ref: T.untyped,
+      revision: T.untyped,
+      git: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(path, uri, ref, revision=T.unsafe(nil), git=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path(); end
 
   sig do
     params(
-      path: ::T.untyped,
+      path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def path=(path); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ref(); end
 
   sig do
     params(
-      ref: ::T.untyped,
+      ref: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ref=(ref); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def revision(); end
 
   sig do
     params(
-      revision: ::T.untyped,
+      revision: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def revision=(revision); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def uri(); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def uri=(uri); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 end
 
 class Bundler::Source::Git::MissingGitRevisionError < Bundler::GitError
   sig do
     params(
-      ref: ::T.untyped,
-      repo: ::T.untyped,
+      ref: T.untyped,
+      repo: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(ref, repo); end
 end
@@ -7511,441 +7645,441 @@ end
 class Bundler::Source::Metadata < Bundler::Source
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cached!(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      _opts: ::T.untyped,
+      spec: T.untyped,
+      _opts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install(spec, _opts=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def options(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def version_message(spec); end
 end
 
 class Bundler::Source::Path < Bundler::Source
-  DEFAULT_GLOB = ::T.let(nil, ::T.untyped)
+  DEFAULT_GLOB = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def app_cache_dirname(); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      custom_path: ::T.untyped,
+      spec: T.untyped,
+      custom_path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cache(spec, custom_path=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cached!(); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def expanded_original_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(options); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      options: ::T.untyped,
+      spec: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install(spec, options=T.unsafe(nil)); end
 
   sig do
     params(
-      _: ::T.untyped,
+      _: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def local_specs(*_); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def name=(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def options(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def original_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def root(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def root_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_lock(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def version(); end
 
   sig do
     params(
-      version: ::T.untyped,
+      version: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def version=(version); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.from_lock(options); end
 end
 
 class Bundler::Source::Rubygems < Bundler::Source
-  API_REQUEST_LIMIT = ::T.let(nil, ::T.untyped)
-  API_REQUEST_SIZE = ::T.let(nil, ::T.untyped)
+  API_REQUEST_LIMIT = ::T.let(nil, T.untyped)
+  API_REQUEST_SIZE = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ==(other); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_remote(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def api_fetchers(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def builtin_gem?(spec); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      custom_path: ::T.untyped,
+      spec: T.untyped,
+      custom_path: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cache(spec, custom_path=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cache_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cached!(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cached_built_in_gem(spec); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cached_gem(spec); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def cached_path(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cached_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def caches(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def can_lock?(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def credless_remotes(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def dependency_names_to_double_check(); end
 
   sig do
     params(
-      unmet_dependency_names: ::T.untyped,
+      unmet_dependency_names: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def double_check_for(unmet_dependency_names); end
 
   sig do
     params(
-      other: ::T.untyped,
+      other: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def eql?(other); end
 
   sig do
     params(
-      other_remotes: ::T.untyped,
+      other_remotes: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def equivalent_remotes?(other_remotes); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def fetch_gem(spec); end
 
   sig do
     params(
-      fetchers: ::T.untyped,
-      dependency_names: ::T.untyped,
-      index: ::T.untyped,
-      override_dupes: ::T.untyped,
+      fetchers: T.untyped,
+      dependency_names: T.untyped,
+      index: T.untyped,
+      override_dupes: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def fetch_names(fetchers, dependency_names, index, override_dupes); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def fetchers(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def hash(); end
 
   sig do
     params(
-      o: ::T.untyped,
+      o: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def include?(o); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(options=T.unsafe(nil)); end
 
   sig do
     params(
-      spec: ::T.untyped,
-      opts: ::T.untyped,
+      spec: T.untyped,
+      opts: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def install(spec, opts=T.unsafe(nil)); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def installed?(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def installed_specs(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def loaded_from(spec); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def name(); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def normalize_uri(uri); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def options(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote_specs(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remotes(); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remotes_for_spec(spec); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remove_auth(remote); end
 
   sig do
     params(
-      other_remotes: ::T.untyped,
-      allow_equivalent: ::T.untyped,
+      other_remotes: T.untyped,
+      allow_equivalent: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def replace_remotes(other_remotes, allow_equivalent=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def requires_sudo?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rubygems_dir(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def specs(); end
 
   sig do
     params(
-      remote: ::T.untyped,
+      remote: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def suppress_configured_credentials(remote); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_lock(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_s(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unmet_deps(); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.from_lock(options); end
 end
@@ -7953,369 +8087,370 @@ end
 class Bundler::SourceList
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_git_source(options=T.unsafe(nil)); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_path_source(options=T.unsafe(nil)); end
 
   sig do
     params(
-      source: ::T.untyped,
-      options: ::T.untyped,
+      source: T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_plugin_source(source, options=T.unsafe(nil)); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_rubygems_remote(uri); end
 
   sig do
     params(
-      options: ::T.untyped,
+      options: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_rubygems_source(options=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def all_sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def cached!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_source(); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def get(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def git_sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def global_rubygems_source(); end
 
   sig do
     params(
-      uri: ::T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def global_rubygems_source=(uri); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def lock_sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def metadata_source(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def path_sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def plugin_sources(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def remote!(); end
 
   sig do
     params(
-      replacement_sources: ::T.untyped,
+      replacement_sources: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def replace_sources!(replacement_sources); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rubygems_primary_remotes(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rubygems_remotes(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def rubygems_sources(); end
 end
 
 class Bundler::SpecSet
   include ::TSort
-  include ::Enumerable
+  include T::Enumerable
   extend ::Forwardable
+
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def <<(*args, &block); end
 
   sig do
     params(
-      key: ::T.untyped,
+      key: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def [](key); end
 
   sig do
     params(
-      key: ::T.untyped,
-      value: ::T.untyped,
+      key: T.untyped,
+      value: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def []=(key, value); end
 
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add(*args, &block); end
 
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def each(*args, &block); end
 
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def empty?(*args, &block); end
 
   sig do
     params(
-      name: ::T.untyped,
-      platform: ::T.untyped,
+      name: T.untyped,
+      platform: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def find_by_name_and_platform(name, platform); end
 
   sig do
     params(
-      dependencies: ::T.untyped,
-      skip: ::T.untyped,
-      check: ::T.untyped,
-      match_current_platform: ::T.untyped,
-      raise_on_missing: ::T.untyped,
+      dependencies: T.untyped,
+      skip: T.untyped,
+      check: T.untyped,
+      match_current_platform: T.untyped,
+      raise_on_missing: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def for(dependencies, skip=T.unsafe(nil), check=T.unsafe(nil), match_current_platform=T.unsafe(nil), raise_on_missing=T.unsafe(nil)); end
 
   sig do
     params(
-      specs: ::T.untyped,
+      specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(specs); end
 
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def length(*args, &block); end
 
   sig do
     params(
-      deps: ::T.untyped,
-      missing_specs: ::T.untyped,
+      deps: T.untyped,
+      missing_specs: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def materialize(deps, missing_specs=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def materialized_for_all_platforms(); end
 
   sig do
     params(
-      set: ::T.untyped,
+      set: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def merge(set); end
 
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def remove(*args, &block); end
 
   sig do
     params(
-      args: ::T.untyped,
-      block: ::T.untyped,
+      args: T.untyped,
+      block: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def size(*args, &block); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def sort!(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_a(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_hash(); end
 
   sig do
     params(
-      deps: ::T.untyped,
+      deps: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def valid_for?(deps); end
 
   sig do
     params(
-      spec: ::T.untyped,
+      spec: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def what_required(spec); end
 end
 
 class Bundler::StubSpecification < Bundler::RemoteSpecification
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def activated(); end
 
   sig do
     params(
-      activated: ::T.untyped,
+      activated: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def activated=(activated); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def default_gem(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def full_gem_path(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def full_require_paths(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def ignored(); end
 
   sig do
     params(
-      ignored: ::T.untyped,
+      ignored: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ignored=(ignored); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def load_paths(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def loaded_from(); end
 
   sig do
     params(
-      glob: ::T.untyped,
+      glob: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def matches_for_glob(glob); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def missing_extensions?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def raw_require_paths(); end
 
   sig do
     params(
-      source: ::T.untyped,
+      source: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def source=(source); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def stub(); end
 
   sig do
     params(
-      stub: ::T.untyped,
+      stub: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def stub=(stub); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def to_yaml(); end
 
   sig do
     params(
-      stub: ::T.untyped,
+      stub: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.from_stub(stub); end
 end
 
 class Bundler::SudoNotPermittedError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::TemporaryResourceError < Bundler::PermissionError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::ThreadCreationError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
@@ -8325,17 +8460,17 @@ end
 class Bundler::UI::RGProxy < Gem::SilentUI
   sig do
     params(
-      ui: ::T.untyped,
+      ui: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(ui); end
 
   sig do
     params(
-      message: ::T.untyped,
+      message: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def say(message); end
 end
@@ -8343,123 +8478,123 @@ end
 class Bundler::UI::Silent
   sig do
     params(
-      string: ::T.untyped,
-      color: ::T.untyped,
+      string: T.untyped,
+      color: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def add_color(string, color); end
 
   sig do
     params(
-      message: ::T.untyped,
+      message: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def ask(message); end
 
   sig do
     params(
-      message: ::T.untyped,
-      newline: ::T.untyped,
+      message: T.untyped,
+      newline: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def confirm(message, newline=T.unsafe(nil)); end
 
   sig do
     params(
-      message: ::T.untyped,
-      newline: ::T.untyped,
+      message: T.untyped,
+      newline: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def debug(message, newline=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def debug?(); end
 
   sig do
     params(
-      message: ::T.untyped,
-      newline: ::T.untyped,
+      message: T.untyped,
+      newline: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def error(message, newline=T.unsafe(nil)); end
 
   sig do
     params(
-      message: ::T.untyped,
-      newline: ::T.untyped,
+      message: T.untyped,
+      newline: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def info(message, newline=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def initialize(); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def level(name=T.unsafe(nil)); end
 
   sig do
     params(
-      name: ::T.untyped,
+      name: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def level=(name); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def no?(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def quiet?(); end
 
   sig do
     params(
-      shell: ::T.untyped,
+      shell: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def shell=(shell); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def silence(); end
 
   sig do
     params(
-      message: ::T.untyped,
-      newline: ::T.untyped,
-      force: ::T.untyped,
+      message: T.untyped,
+      newline: T.untyped,
+      force: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def trace(message, newline=T.unsafe(nil), force=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def unprinted_warnings(); end
 
   sig do
     params(
-      message: ::T.untyped,
-      newline: ::T.untyped,
+      message: T.untyped,
+      newline: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def warn(message, newline=T.unsafe(nil)); end
 
   sig do
     params(
-      msg: ::T.untyped,
+      msg: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def yes?(msg); end
 end
@@ -8467,64 +8602,64 @@ end
 module Bundler::URICredentialsFilter
   sig do
     params(
-      str_to_filter: ::T.untyped,
-      uri: ::T.untyped,
+      str_to_filter: T.untyped,
+      uri: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.credential_filtered_string(str_to_filter, uri); end
 
   sig do
     params(
-      uri_to_anonymize: ::T.untyped,
+      uri_to_anonymize: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.credential_filtered_uri(uri_to_anonymize); end
 end
 
 class Bundler::VersionConflict < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def conflicts(); end
 
   sig do
     params(
-      conflicts: ::T.untyped,
-      msg: ::T.untyped,
+      conflicts: T.untyped,
+      msg: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(conflicts, msg=T.unsafe(nil)); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 class Bundler::VirtualProtocolError < Bundler::BundlerError
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def message(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
 
 module Bundler::YAMLSerializer
-  ARRAY_REGEX = ::T.let(nil, ::T.untyped)
-  HASH_REGEX = ::T.let(nil, ::T.untyped)
+  ARRAY_REGEX = ::T.let(nil, T.untyped)
+  HASH_REGEX = ::T.let(nil, T.untyped)
 
   sig do
     params(
-      hash: ::T.untyped,
+      hash: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.dump(hash); end
 
   sig do
     params(
-      str: ::T.untyped,
+      str: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def self.load(str); end
 end
@@ -8532,16 +8667,16 @@ end
 class Bundler::YamlSyntaxError < Bundler::BundlerError
   sig do
     params(
-      orig_exception: ::T.untyped,
-      msg: ::T.untyped,
+      orig_exception: T.untyped,
+      msg: T.untyped,
     )
-    .returns(::T.untyped)
+    .returns(T.untyped)
   end
   def initialize(orig_exception, msg); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def orig_exception(); end
 
-  sig {returns(::T.untyped)}
+  sig {returns(T.untyped)}
   def status_code(); end
 end
diff --git a/base/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi b/base/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi
new file mode 100644
index 0000000..2f8d981
--- /dev/null
+++ b/base/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi
@@ -0,0 +1,4222 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/gem.rbi
+#
+# typed: strong
+module Gem
+  ConfigMap = T.let(nil, T.untyped)
+  RbConfigPriorities = T.let(nil, T.untyped)
+  RubyGemsPackageVersion = T.let(nil, T.untyped)
+  RubyGemsVersion = T.let(nil, T.untyped)
+  USE_BUNDLER_FOR_GEMDEPS = T.let(nil, T.untyped)
+
+  def self._deprecated_detect_gemdeps(path = T.unsafe(nil)); end
+
+  def self._deprecated_gunzip(data); end
+
+  def self._deprecated_gzip(data); end
+
+  def self._deprecated_inflate(data); end
+
+  def self.activate_bin_path(name, *args); end
+
+  def self.default_ext_dir_for(base_dir); end
+
+  def self.default_gems_use_full_paths?; end
+
+  def self.default_spec_cache_dir; end
+
+  def self.deflate(data); end
+
+  def self.detect_gemdeps(*args, &block); end
+
+  def self.dir; end
+
+  def self.done_installing(&hook); end
+
+  def self.done_installing_hooks; end
+
+  def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil); end
+
+  def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil); end
+
+  def self.ensure_subdirectories(dir, mode, subdirs); end
+
+  def self.env_requirement(gem_name); end
+
+  def self.extension_api_version; end
+
+  def self.find_files(glob, check_load_path = true); end
+
+  def self.find_files_from_load_path(glob); end
+
+  def self.find_latest_files(glob, check_load_path = T.unsafe(nil)); end
+
+  def self.find_unresolved_default_spec(path); end
+
+  def self.finish_resolve(*_); end
+
+  def self.gemdeps; end
+
+  def self.gunzip(*args, &block); end
+
+  def self.gzip(*args, &block); end
+
+  def self.host; end
+
+  def self.host=(host); end
+
+  def self.inflate(*args, &block); end
+
+  def self.install(name, version = T.unsafe(nil), *options); end
+
+  def self.install_extension_in_lib; end
+
+  def self.latest_rubygems_version; end
+
+  def self.latest_spec_for(name); end
+
+  def self.latest_version_for(name); end
+
+  def self.load_env_plugins; end
+
+  def self.load_path_insert_index; end
+
+  def self.load_plugin_files(plugins); end
+
+  def self.load_plugins; end
+
+  def self.load_yaml; end
+
+  def self.loaded_specs; end
+
+  def self.location_of_caller(depth = T.unsafe(nil)); end
+
+  def self.marshal_version; end
+
+  def self.needs; end
+
+  def self.operating_system_defaults; end
+
+  def self.path; end
+
+  def self.path_separator; end
+
+  def self.paths; end
+
+  def self.paths=(env); end
+
+  def self.platform_defaults; end
+
+  def self.platforms; end
+
+  def self.platforms=(platforms); end
+
+  def self.post_build(&hook); end
+
+  def self.post_build_hooks; end
+
+  def self.post_install(&hook); end
+
+  def self.post_install_hooks; end
+
+  def self.post_reset(&hook); end
+
+  def self.post_reset_hooks; end
+
+  def self.post_uninstall(&hook); end
+
+  def self.post_uninstall_hooks; end
+
+  def self.pre_install(&hook); end
+
+  def self.pre_install_hooks; end
+
+  def self.pre_reset(&hook); end
+
+  def self.pre_reset_hooks; end
+
+  def self.pre_uninstall(&hook); end
+
+  def self.pre_uninstall_hooks; end
+
+  def self.prefix; end
+
+  def self.read_binary(path); end
+
+  def self.refresh; end
+
+  def self.register_default_spec(spec); end
+
+  def self.remove_unresolved_default_spec(spec); end
+
+  def self.ruby; end
+
+  def self.ruby_api_version; end
+
+  def self.ruby_engine; end
+
+  def self.ruby_version; end
+
+  def self.rubygems_version; end
+
+  def self.sources; end
+
+  def self.sources=(new_sources); end
+
+  def self.spec_cache_dir; end
+
+  def self.suffix_pattern; end
+
+  def self.suffixes; end
+
+  def self.time(msg, width = T.unsafe(nil), display = T.unsafe(nil)); end
+
+  def self.try_activate(path); end
+
+  def self.ui; end
+
+  def self.use_gemdeps(path = T.unsafe(nil)); end
+
+  def self.use_paths(home, *paths); end
+
+  def self.user_dir; end
+
+  def self.user_home; end
+
+  def self.vendor_dir; end
+
+  def self.win_platform?; end
+
+  def self.write_binary(path, data); end
+
+  class AvailableSet
+    include Enumerable
+    Elem = type_member(fixed: T.untyped)
+
+    def <<(o); end
+
+    def add(spec, source); end
+
+    def all_specs; end
+
+    def each(&blk); end
+
+    def each_spec; end
+
+    def empty?; end
+
+    def find_all(req); end
+
+    def inject_into_list(dep_list); end
+
+    def match_platform!; end
+
+    def pick_best!; end
+
+    def prefetch(reqs); end
+
+    def remote; end
+
+    def remote=(remote); end
+
+    def remove_installed!(dep); end
+
+    def set; end
+
+    def size; end
+
+    def sorted; end
+
+    def source_for(spec); end
+
+    def to_request_set(development = T.unsafe(nil)); end
+
+    class Tuple
+      def source; end
+
+      def source=(_); end
+
+      def spec; end
+
+      def spec=(_); end
+
+      def self.[](*_); end
+
+      def self.members; end
+    end
+  end
+
+  class BasicSpecification
+    def activated?; end
+
+    def base_dir; end
+
+    def base_dir=(base_dir); end
+
+    def contains_requirable_file?(file); end
+
+    def datadir; end
+
+    def default_gem?; end
+
+    def extension_dir; end
+
+    def extension_dir=(extension_dir); end
+
+    def extensions_dir; end
+
+    def full_gem_path; end
+
+    def full_gem_path=(full_gem_path); end
+
+    def full_name; end
+
+    def full_require_paths; end
+
+    def gem_build_complete_path; end
+
+    def gem_dir; end
+
+    def gems_dir; end
+
+    def ignored=(ignored); end
+
+    def internal_init; end
+
+    def lib_dirs_glob; end
+
+    def loaded_from; end
+
+    def loaded_from=(loaded_from); end
+
+    def matches_for_glob(glob); end
+
+    def name; end
+
+    def platform; end
+
+    def raw_require_paths; end
+
+    def require_paths; end
+
+    def source_paths; end
+
+    def stubbed?; end
+
+    def this; end
+
+    def to_fullpath(path); end
+
+    def to_spec; end
+
+    def version; end
+
+    def self.default_specifications_dir; end
+  end
+
+  module BundlerVersionFinder
+    def self.bundler_version; end
+
+    def self.bundler_version_with_reason; end
+
+    def self.compatible?(spec); end
+
+    def self.filter!(specs); end
+
+    def self.missing_version_message; end
+  end
+
+  class Command
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    HELP = T.let(nil, T.untyped)
+
+    def add_extra_args(args); end
+
+    def add_option(*opts, &handler); end
+
+    def arguments; end
+
+    def begins?(long, short); end
+
+    def command; end
+
+    def defaults; end
+
+    def defaults=(defaults); end
+
+    def defaults_str; end
+
+    def description; end
+
+    def execute; end
+
+    def get_all_gem_names; end
+
+    def get_all_gem_names_and_versions; end
+
+    def get_one_gem_name; end
+
+    def get_one_optional_argument; end
+
+    def handle_options(args); end
+
+    def handles?(args); end
+
+    def initialize(command, summary = T.unsafe(nil), defaults = T.unsafe(nil)); end
+
+    def invoke(*args); end
+
+    def invoke_with_build_args(args, build_args); end
+
+    def merge_options(new_options); end
+
+    def options; end
+
+    def program_name; end
+
+    def program_name=(program_name); end
+
+    def remove_option(name); end
+
+    def show_help; end
+
+    def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end
+
+    def summary; end
+
+    def summary=(summary); end
+
+    def usage; end
+
+    def when_invoked(&block); end
+
+    def self.add_common_option(*args, &handler); end
+
+    def self.add_specific_extra_args(cmd, args); end
+
+    def self.build_args; end
+
+    def self.build_args=(value); end
+
+    def self.common_options; end
+
+    def self.extra_args; end
+
+    def self.extra_args=(value); end
+
+    def self.specific_extra_args(cmd); end
+
+    def self.specific_extra_args_hash; end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  module Commands
+  end
+
+  class ConfigFile
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    DEFAULT_BACKTRACE = T.let(nil, T.untyped)
+    DEFAULT_BULK_THRESHOLD = T.let(nil, T.untyped)
+    DEFAULT_CERT_EXPIRATION_LENGTH_DAYS = T.let(nil, T.untyped)
+    DEFAULT_CONCURRENT_DOWNLOADS = T.let(nil, T.untyped)
+    DEFAULT_UPDATE_SOURCES = T.let(nil, T.untyped)
+    DEFAULT_VERBOSITY = T.let(nil, T.untyped)
+    OPERATING_SYSTEM_DEFAULTS = T.let(nil, T.untyped)
+    PLATFORM_DEFAULTS = T.let(nil, T.untyped)
+    SYSTEM_CONFIG_PATH = T.let(nil, T.untyped)
+    SYSTEM_WIDE_CONFIG_FILE = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def [](key); end
+
+    def []=(key, value); end
+
+    def api_keys; end
+
+    def args; end
+
+    def backtrace; end
+
+    def backtrace=(backtrace); end
+
+    def bulk_threshold; end
+
+    def bulk_threshold=(bulk_threshold); end
+
+    def cert_expiration_length_days; end
+
+    def cert_expiration_length_days=(cert_expiration_length_days); end
+
+    def check_credentials_permissions; end
+
+    def concurrent_downloads; end
+
+    def concurrent_downloads=(concurrent_downloads); end
+
+    def config_file_name; end
+
+    def credentials_path; end
+
+    def disable_default_gem_server; end
+
+    def disable_default_gem_server=(disable_default_gem_server); end
+
+    def each(&block); end
+
+    def handle_arguments(arg_list); end
+
+    def home; end
+
+    def home=(home); end
+
+    def initialize(args); end
+
+    def load_api_keys; end
+
+    def load_file(filename); end
+
+    def path; end
+
+    def path=(path); end
+
+    def really_verbose; end
+
+    def rubygems_api_key; end
+
+    def rubygems_api_key=(api_key); end
+
+    def set_api_key(host, api_key); end
+
+    def sources; end
+
+    def sources=(sources); end
+
+    def ssl_ca_cert; end
+
+    def ssl_ca_cert=(ssl_ca_cert); end
+
+    def ssl_client_cert; end
+
+    def ssl_verify_mode; end
+
+    def to_yaml; end
+
+    def unset_api_key!; end
+
+    def update_sources; end
+
+    def update_sources=(update_sources); end
+
+    def verbose; end
+
+    def verbose=(verbose); end
+
+    def write; end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+  end
+
+  class ConflictError
+    def conflicts; end
+
+    def initialize(target, conflicts); end
+
+    def target; end
+  end
+
+  class ConsoleUI
+    def initialize; end
+  end
+
+  module DefaultUserInteraction
+    include Gem::Text
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def self.ui; end
+
+    def self.ui=(new_ui); end
+
+    def self.use_ui(new_ui); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+  end
+
+  class Dependency
+    def ==(other); end
+
+    def ===(other); end
+
+    def =~(other); end
+
+    def all_sources; end
+
+    def all_sources=(all_sources); end
+
+    def encode_with(coder); end
+
+    def eql?(other); end
+
+    def groups; end
+
+    def groups=(groups); end
+
+    def initialize(name, *requirements); end
+
+    def latest_version?; end
+
+    def match?(obj, version = T.unsafe(nil), allow_prerelease = T.unsafe(nil)); end
+
+    def matches_spec?(spec); end
+
+    def matching_specs(platform_only = T.unsafe(nil)); end
+
+    def merge(other); end
+
+    def name; end
+
+    def name=(name); end
+
+    def prerelease=(prerelease); end
+
+    def prerelease?; end
+
+    def pretty_print(q); end
+
+    def requirement; end
+
+    def requirements_list; end
+
+    def runtime?; end
+
+    def source; end
+
+    def source=(source); end
+
+    def specific?; end
+
+    def to_lock; end
+
+    def to_spec; end
+
+    def to_specs; end
+
+    def to_yaml_properties; end
+
+    def type; end
+  end
+
+  class DependencyInstaller
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    extend Gem::Deprecate
+    DEFAULT_OPTIONS = T.let(nil, T.untyped)
+
+    def _deprecated_add_found_dependencies(to_do, dependency_list); end
+
+    def _deprecated_gather_dependencies; end
+
+    def add_found_dependencies(*args, &block); end
+
+    def available_set_for(dep_or_name, version); end
+
+    def consider_local?; end
+
+    def consider_remote?; end
+
+    def document; end
+
+    def errors; end
+
+    def find_gems_with_sources(dep, best_only = T.unsafe(nil)); end
+
+    def find_spec_by_name_and_version(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end
+
+    def gather_dependencies(*args, &block); end
+
+    def in_background(what); end
+
+    def initialize(options = T.unsafe(nil)); end
+
+    def install(dep_or_name, version = T.unsafe(nil)); end
+
+    def install_development_deps; end
+
+    def installed_gems; end
+
+    def resolve_dependencies(dep_or_name, version); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class DependencyList
+    include Enumerable
+    include TSort
+    Elem = type_member(fixed: T.untyped)
+
+    def add(*gemspecs); end
+
+    def clear; end
+
+    def dependency_order; end
+
+    def development; end
+
+    def development=(development); end
+
+    def each(&block); end
+
+    def find_name(full_name); end
+
+    def initialize(development = T.unsafe(nil)); end
+
+    def ok?; end
+
+    def ok_to_remove?(full_name, check_dev = T.unsafe(nil)); end
+
+    def remove_by_name(full_name); end
+
+    def remove_specs_unsatisfied_by(dependencies); end
+
+    def spec_predecessors; end
+
+    def specs; end
+
+    def tsort_each_node(&block); end
+
+    def why_not_ok?(quick = T.unsafe(nil)); end
+
+    def self.from_specs; end
+  end
+
+  class DependencyResolutionError
+    def conflict; end
+
+    def conflicting_dependencies; end
+
+    def initialize(conflict); end
+  end
+
+  module Deprecate
+    def self.deprecate(name, repl, year, month); end
+
+    def self.skip; end
+
+    def self.skip=(v); end
+
+    def self.skip_during; end
+  end
+
+  class Exception
+    extend Gem::Deprecate
+
+    def _deprecated_source_exception; end
+
+    def source_exception(*args, &block); end
+
+    def source_exception=(source_exception); end
+  end
+
+  module Ext
+    class BuildError
+    end
+
+    class Builder
+      include Gem::UserInteraction
+      include Gem::DefaultUserInteraction
+      include Gem::Text
+      CHDIR_MONITOR = T.let(nil, T.untyped)
+      CHDIR_MUTEX = T.let(nil, T.untyped)
+
+      def build_args; end
+
+      def build_args=(build_args); end
+
+      def build_error(build_dir, output, backtrace = T.unsafe(nil)); end
+
+      def build_extension(extension, dest_path); end
+
+      def build_extensions; end
+
+      def builder_for(extension); end
+
+      def initialize(spec, build_args = T.unsafe(nil)); end
+
+      def write_gem_make_out(output); end
+
+      def self.class_name; end
+
+      def self.make(dest_path, results); end
+
+      def self.redirector; end
+
+      def self.run(command, results, command_name = T.unsafe(nil)); end
+
+      def clean_text(text); end
+
+      def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+      def levenshtein_distance(str1, str2); end
+
+      def min3(a, b, c); end
+
+      def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+      def ui; end
+
+      def ui=(new_ui); end
+
+      def use_ui(new_ui, &block); end
+
+      def alert(statement, question = T.unsafe(nil)); end
+
+      def alert_error(statement, question = T.unsafe(nil)); end
+
+      def alert_warning(statement, question = T.unsafe(nil)); end
+
+      def ask(question); end
+
+      def ask_for_password(prompt); end
+
+      def ask_yes_no(question, default = T.unsafe(nil)); end
+
+      def choose_from_list(question, list); end
+
+      def say(statement = T.unsafe(nil)); end
+
+      def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+      def verbose(msg = T.unsafe(nil)); end
+    end
+
+    class CmakeBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+    end
+
+    class ConfigureBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+    end
+
+    class ExtConfBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+
+      def self.get_relative_path(path); end
+    end
+
+    class RakeBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+    end
+  end
+
+  class FilePermissionError
+    def directory; end
+
+    def initialize(directory); end
+  end
+
+  class FormatException
+    def file_path; end
+
+    def file_path=(file_path); end
+  end
+
+  class GemNotInHomeException
+    def spec; end
+
+    def spec=(spec); end
+  end
+
+  class ImpossibleDependenciesError
+    def build_message; end
+
+    def conflicts; end
+
+    def dependency; end
+
+    def initialize(request, conflicts); end
+
+    def request; end
+  end
+
+  class Installer
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    extend Gem::Deprecate
+    ENV_PATHS = T.let(nil, T.untyped)
+
+    def _deprecated_extension_build_error(build_dir, output, backtrace = T.unsafe(nil)); end
+
+    def app_script_text(bin_file_name); end
+
+    def bin_dir; end
+
+    def build_extensions; end
+
+    def build_root; end
+
+    def check_executable_overwrite(filename); end
+
+    def check_that_user_bin_dir_is_in_path; end
+
+    def default_spec_file; end
+
+    def dir; end
+
+    def ensure_dependencies_met; end
+
+    def ensure_dependency(spec, dependency); end
+
+    def ensure_loadable_spec; end
+
+    def ensure_required_ruby_version_met; end
+
+    def ensure_required_rubygems_version_met; end
+
+    def extension_build_error(*args, &block); end
+
+    def extract_bin; end
+
+    def extract_files; end
+
+    def formatted_program_filename(filename); end
+
+    def gem; end
+
+    def gem_dir; end
+
+    def gem_home; end
+
+    def generate_bin; end
+
+    def generate_bin_script(filename, bindir); end
+
+    def generate_bin_symlink(filename, bindir); end
+
+    def generate_windows_script(filename, bindir); end
+
+    def initialize(package, options = T.unsafe(nil)); end
+
+    def install; end
+
+    def installation_satisfies_dependency?(dependency); end
+
+    def installed_specs; end
+
+    def options; end
+
+    def pre_install_checks; end
+
+    def process_options; end
+
+    def run_post_build_hooks; end
+
+    def run_post_install_hooks; end
+
+    def run_pre_install_hooks; end
+
+    def shebang(bin_file_name); end
+
+    def spec; end
+
+    def spec_file; end
+
+    def unpack(directory); end
+
+    def verify_gem_home(unpack = T.unsafe(nil)); end
+
+    def verify_spec; end
+
+    def windows_stub_script(bindir, bin_file_name); end
+
+    def write_build_info_file; end
+
+    def write_cache_file; end
+
+    def write_default_spec; end
+
+    def write_spec; end
+
+    def self.at(path, options = T.unsafe(nil)); end
+
+    def self.exec_format; end
+
+    def self.exec_format=(exec_format); end
+
+    def self.for_spec(spec, options = T.unsafe(nil)); end
+
+    def self.install_lock; end
+
+    def self.path_warning; end
+
+    def self.path_warning=(path_warning); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class Licenses
+    extend Gem::Text
+    EXCEPTION_IDENTIFIERS = T.let(nil, T.untyped)
+    LICENSE_IDENTIFIERS = T.let(nil, T.untyped)
+    NONSTANDARD = T.let(nil, T.untyped)
+    REGEXP = T.let(nil, T.untyped)
+
+    def self.match?(license); end
+
+    def self.suggestions(license); end
+
+    def self.clean_text(text); end
+
+    def self.format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def self.levenshtein_distance(str1, str2); end
+
+    def self.min3(a, b, c); end
+
+    def self.truncate_text(text, description, max_length = T.unsafe(nil)); end
+  end
+
+  class List
+    def each(&blk); end
+
+    def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end
+
+    def prepend(value); end
+
+    def pretty_print(q); end
+
+    def tail; end
+
+    def tail=(tail); end
+
+    def to_a; end
+
+    def value; end
+
+    def value=(value); end
+
+    def self.prepend(list, value); end
+  end
+
+  class LoadError
+    def name; end
+
+    def name=(name); end
+
+    def requirement; end
+
+    def requirement=(requirement); end
+  end
+
+  class MissingSpecError
+    def initialize(name, requirement); end
+  end
+
+  class MissingSpecVersionError
+    def initialize(name, requirement, specs); end
+
+    def specs; end
+  end
+
+  class NameTuple
+    include Comparable
+
+    def ==(other); end
+
+    def eql?(other); end
+
+    def full_name; end
+
+    def initialize(name, version, platform = T.unsafe(nil)); end
+
+    def match_platform?; end
+
+    def name; end
+
+    def platform; end
+
+    def prerelease?; end
+
+    def spec_name; end
+
+    def to_a; end
+
+    def version; end
+
+    def self.from_list(list); end
+
+    def self.null; end
+
+    def self.to_basic(list); end
+  end
+
+  class Package
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+
+    def add_checksums(tar); end
+
+    def add_contents(tar); end
+
+    def add_files(tar); end
+
+    def add_metadata(tar); end
+
+    def build(skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil)); end
+
+    def build_time; end
+
+    def build_time=(build_time); end
+
+    def checksums; end
+
+    def contents; end
+
+    def copy_to(path); end
+
+    def data_mode; end
+
+    def data_mode=(data_mode); end
+
+    def digest(entry); end
+
+    def dir_mode; end
+
+    def dir_mode=(dir_mode); end
+
+    def extract_files(destination_dir, pattern = T.unsafe(nil)); end
+
+    def extract_tar_gz(io, destination_dir, pattern = T.unsafe(nil)); end
+
+    def file_mode(mode); end
+
+    def files; end
+
+    def gzip_to(io); end
+
+    def initialize(gem, security_policy); end
+
+    def install_location(filename, destination_dir); end
+
+    def load_spec(entry); end
+
+    def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end
+
+    def normalize_path(pathname); end
+
+    def open_tar_gz(io); end
+
+    def prog_mode; end
+
+    def prog_mode=(prog_mode); end
+
+    def read_checksums(gem); end
+
+    def security_policy; end
+
+    def security_policy=(security_policy); end
+
+    def setup_signer(signer_options: T.unsafe(nil)); end
+
+    def spec; end
+
+    def spec=(spec); end
+
+    def verify; end
+
+    def verify_checksums(digests, checksums); end
+
+    def verify_entry(entry); end
+
+    def verify_files(gem); end
+
+    def verify_gz(entry); end
+
+    def self.build(spec, skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil), file_name = T.unsafe(nil)); end
+
+    def self.new(gem, security_policy = T.unsafe(nil)); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+
+    class DigestIO
+      def digests; end
+
+      def initialize(io, digests); end
+
+      def write(data); end
+
+      def self.wrap(io, digests); end
+    end
+
+    class Error
+    end
+
+    class FileSource
+      def initialize(path); end
+
+      def path; end
+
+      def present?; end
+
+      def start; end
+
+      def with_read_io(&block); end
+
+      def with_write_io(&block); end
+    end
+
+    class FormatError
+      def initialize(message, source = T.unsafe(nil)); end
+
+      def path; end
+    end
+
+    class IOSource
+      def initialize(io); end
+
+      def io; end
+
+      def path; end
+
+      def present?; end
+
+      def start; end
+
+      def with_read_io; end
+
+      def with_write_io; end
+    end
+
+    class NonSeekableIO
+    end
+
+    class Old
+      def extract_files(destination_dir); end
+
+      def file_list(io); end
+
+      def read_until_dashes(io); end
+
+      def skip_ruby(io); end
+    end
+
+    class PathError
+      def initialize(destination, destination_dir); end
+    end
+
+    class Source
+    end
+
+    class TarHeader
+      EMPTY_HEADER = T.let(nil, T.untyped)
+      FIELDS = T.let(nil, T.untyped)
+      PACK_FORMAT = T.let(nil, T.untyped)
+      UNPACK_FORMAT = T.let(nil, T.untyped)
+
+      def ==(other); end
+
+      def checksum; end
+
+      def devmajor; end
+
+      def devminor; end
+
+      def empty?; end
+
+      def gid; end
+
+      def gname; end
+
+      def initialize(vals); end
+
+      def linkname; end
+
+      def magic; end
+
+      def mode; end
+
+      def mtime; end
+
+      def name; end
+
+      def prefix; end
+
+      def size; end
+
+      def typeflag; end
+
+      def uid; end
+
+      def uname; end
+
+      def update_checksum; end
+
+      def version; end
+
+      def self.from(stream); end
+
+      def self.strict_oct(str); end
+    end
+
+    class TarInvalidError
+    end
+
+    class TarReader
+      include Enumerable
+      Elem = type_member(fixed: T.untyped)
+
+      def close; end
+
+      def each(&blk); end
+
+      def each_entry; end
+
+      def initialize(io); end
+
+      def rewind; end
+
+      def seek(name); end
+
+      def self.new(io); end
+
+      class Entry
+        def bytes_read; end
+
+        def check_closed; end
+
+        def close; end
+
+        def closed?; end
+
+        def directory?; end
+
+        def eof?; end
+
+        def file?; end
+
+        def full_name; end
+
+        def getc; end
+
+        def header; end
+
+        def initialize(header, io); end
+
+        def length; end
+
+        def pos; end
+
+        def read(len = T.unsafe(nil)); end
+
+        def readpartial(maxlen = T.unsafe(nil), outbuf = T.unsafe(nil)); end
+
+        def rewind; end
+
+        def size; end
+
+        def symlink?; end
+      end
+
+      class UnexpectedEOF
+      end
+    end
+
+    class TarWriter
+      def add_file(name, mode); end
+
+      def add_file_digest(name, mode, digest_algorithms); end
+
+      def add_file_signed(name, mode, signer); end
+
+      def add_file_simple(name, mode, size); end
+
+      def add_symlink(name, target, mode); end
+
+      def check_closed; end
+
+      def close; end
+
+      def closed?; end
+
+      def flush; end
+
+      def initialize(io); end
+
+      def mkdir(name, mode); end
+
+      def split_name(name); end
+
+      def self.new(io); end
+
+      class BoundedStream
+        def initialize(io, limit); end
+
+        def limit; end
+
+        def write(data); end
+
+        def written; end
+      end
+
+      class FileOverflow
+      end
+
+      class RestrictedStream
+        def initialize(io); end
+
+        def write(data); end
+      end
+    end
+
+    class TooLongFileName
+    end
+  end
+
+  class PathSupport
+    def home; end
+
+    def initialize(env); end
+
+    def path; end
+
+    def spec_cache_dir; end
+  end
+
+  class Platform
+    JAVA = T.let(nil, T.untyped)
+    MINGW = T.let(nil, T.untyped)
+    MSWIN = T.let(nil, T.untyped)
+    MSWIN64 = T.let(nil, T.untyped)
+    X64_MINGW = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def ===(other); end
+
+    def =~(other); end
+
+    def cpu; end
+
+    def cpu=(cpu); end
+
+    def eql?(other); end
+
+    def initialize(arch); end
+
+    def os; end
+
+    def os=(os); end
+
+    def to_a; end
+
+    def version; end
+
+    def version=(version); end
+
+    def self.installable?(spec); end
+
+    def self.local; end
+
+    def self.match(platform); end
+
+    def self.new(arch); end
+  end
+
+  class PlatformMismatch
+    def add_platform(platform); end
+
+    def initialize(name, version); end
+
+    def name; end
+
+    def platforms; end
+
+    def version; end
+
+    def wordy; end
+  end
+
+  class RemoteFetcher
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    BASE64_URI_TRANSLATE = T.let(nil, T.untyped)
+
+    def cache_update_path(uri, path = T.unsafe(nil), update = T.unsafe(nil)); end
+
+    def close_all; end
+
+    def correct_for_windows_path(path); end
+
+    def download(spec, source_uri, install_dir = T.unsafe(nil)); end
+
+    def download_to_cache(dependency); end
+
+    def fetch_file(uri, *_); end
+
+    def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end
+
+    def fetch_https(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end
+
+    def fetch_path(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end
+
+    def fetch_s3(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end
+
+    def fetch_size(uri); end
+
+    def headers; end
+
+    def headers=(headers); end
+
+    def https?(uri); end
+
+    def initialize(proxy = T.unsafe(nil), dns = T.unsafe(nil), headers = T.unsafe(nil)); end
+
+    def request(uri, request_class, last_modified = T.unsafe(nil)); end
+
+    def s3_expiration; end
+
+    def sign_s3_url(uri, expiration = T.unsafe(nil)); end
+
+    def self.fetcher; end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class Request
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    extend Gem::UserInteraction
+    extend Gem::DefaultUserInteraction
+    extend Gem::Text
+
+    def cert_files; end
+
+    def connection_for(uri); end
+
+    def fetch; end
+
+    def initialize(uri, request_class, last_modified, pool); end
+
+    def perform_request(request); end
+
+    def proxy_uri; end
+
+    def reset(connection); end
+
+    def user_agent; end
+
+    def self.configure_connection_for_https(connection, cert_files); end
+
+    def self.create_with_proxy(uri, request_class, last_modified, proxy); end
+
+    def self.get_cert_files; end
+
+    def self.get_proxy_from_env(scheme = T.unsafe(nil)); end
+
+    def self.proxy_uri(proxy); end
+
+    def self.verify_certificate(store_context); end
+
+    def self.verify_certificate_message(error_number, cert); end
+
+    def self.clean_text(text); end
+
+    def self.format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def self.levenshtein_distance(str1, str2); end
+
+    def self.min3(a, b, c); end
+
+    def self.truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def self.ui; end
+
+    def self.ui=(new_ui); end
+
+    def self.use_ui(new_ui, &block); end
+
+    def self.alert(statement, question = T.unsafe(nil)); end
+
+    def self.alert_error(statement, question = T.unsafe(nil)); end
+
+    def self.alert_warning(statement, question = T.unsafe(nil)); end
+
+    def self.ask(question); end
+
+    def self.ask_for_password(prompt); end
+
+    def self.ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def self.choose_from_list(question, list); end
+
+    def self.say(statement = T.unsafe(nil)); end
+
+    def self.terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def self.verbose(msg = T.unsafe(nil)); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+
+    class ConnectionPools
+      def close_all; end
+
+      def initialize(proxy_uri, cert_files); end
+
+      def pool_for(uri); end
+
+      def self.client; end
+
+      def self.client=(client); end
+    end
+
+    class HTTPPool
+      def cert_files; end
+
+      def checkin(connection); end
+
+      def checkout; end
+
+      def close_all; end
+
+      def initialize(http_args, cert_files, proxy_uri); end
+
+      def proxy_uri; end
+    end
+
+    class HTTPSPool
+    end
+  end
+
+  class RequestSet
+    include TSort
+
+    def always_install; end
+
+    def always_install=(always_install); end
+
+    def dependencies; end
+
+    def development; end
+
+    def development=(development); end
+
+    def development_shallow; end
+
+    def development_shallow=(development_shallow); end
+
+    def errors; end
+
+    def gem(name, *reqs); end
+
+    def git_set; end
+
+    def ignore_dependencies; end
+
+    def ignore_dependencies=(ignore_dependencies); end
+
+    def import(deps); end
+
+    def initialize(*deps); end
+
+    def install(options, &block); end
+
+    def install_dir; end
+
+    def install_from_gemdeps(options, &block); end
+
+    def install_hooks(requests, options); end
+
+    def install_into(dir, force = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    def load_gemdeps(path, without_groups = T.unsafe(nil), installing = T.unsafe(nil)); end
+
+    def prerelease; end
+
+    def prerelease=(prerelease); end
+
+    def pretty_print(q); end
+
+    def remote; end
+
+    def remote=(remote); end
+
+    def resolve(set = T.unsafe(nil)); end
+
+    def resolve_current; end
+
+    def resolver; end
+
+    def sets; end
+
+    def soft_missing; end
+
+    def soft_missing=(soft_missing); end
+
+    def sorted_requests; end
+
+    def source_set; end
+
+    def specs; end
+
+    def specs_in(dir); end
+
+    def tsort_each_node(&block); end
+
+    def vendor_set; end
+
+    class GemDependencyAPI
+      ENGINE_MAP = T.let(nil, T.untyped)
+      PLATFORM_MAP = T.let(nil, T.untyped)
+      VERSION_MAP = T.let(nil, T.untyped)
+      WINDOWS = T.let(nil, T.untyped)
+
+      def dependencies; end
+
+      def find_gemspec(name, path); end
+
+      def gem(name, *requirements); end
+
+      def gem_deps_file; end
+
+      def gem_git_reference(options); end
+
+      def gemspec(options = T.unsafe(nil)); end
+
+      def git(repository); end
+
+      def git_set; end
+
+      def git_source(name, &callback); end
+
+      def group(*groups); end
+
+      def initialize(set, path); end
+
+      def installing=(installing); end
+
+      def load; end
+
+      def platform(*platforms); end
+
+      def platforms(*platforms); end
+
+      def requires; end
+
+      def ruby(version, options = T.unsafe(nil)); end
+
+      def source(url); end
+
+      def vendor_set; end
+
+      def without_groups; end
+
+      def without_groups=(without_groups); end
+    end
+
+    class Lockfile
+      def add_DEPENDENCIES(out); end
+
+      def add_GEM(out, spec_groups); end
+
+      def add_GIT(out, git_requests); end
+
+      def add_PATH(out, path_requests); end
+
+      def add_PLATFORMS(out); end
+
+      def initialize(request_set, gem_deps_file, dependencies); end
+
+      def platforms; end
+
+      def relative_path_from(dest, base); end
+
+      def spec_groups; end
+
+      def write; end
+
+      def self.build(request_set, gem_deps_file, dependencies = T.unsafe(nil)); end
+
+      def self.requests_to_deps(requests); end
+
+      class ParseError
+        def column; end
+
+        def initialize(message, column, line, path); end
+
+        def line; end
+
+        def path; end
+      end
+
+      class Parser
+        def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end
+
+        def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end
+
+        def parse; end
+
+        def parse_DEPENDENCIES; end
+
+        def parse_GEM; end
+
+        def parse_GIT; end
+
+        def parse_PATH; end
+
+        def parse_PLATFORMS; end
+
+        def parse_dependency(name, op); end
+      end
+
+      class Tokenizer
+        EOF = T.let(nil, T.untyped)
+
+        def empty?; end
+
+        def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end
+
+        def make_parser(set, platforms); end
+
+        def next_token; end
+
+        def peek; end
+
+        def shift; end
+
+        def skip(type); end
+
+        def to_a; end
+
+        def token_pos(byte_offset); end
+
+        def unshift(token); end
+
+        def self.from_file(file); end
+
+        class Token
+          def column; end
+
+          def column=(_); end
+
+          def line; end
+
+          def line=(_); end
+
+          def type; end
+
+          def type=(_); end
+
+          def value; end
+
+          def value=(_); end
+
+          def self.[](*_); end
+
+          def self.members; end
+        end
+      end
+    end
+  end
+
+  class Requirement
+    DefaultRequirement = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def ===(version); end
+
+    def =~(version); end
+
+    def _tilde_requirements; end
+
+    def as_list; end
+
+    def concat(new); end
+
+    def encode_with(coder); end
+
+    def exact?; end
+
+    def for_lockfile; end
+
+    def init_with(coder); end
+
+    def initialize(*requirements); end
+
+    def marshal_dump; end
+
+    def marshal_load(array); end
+
+    def none?; end
+
+    def prerelease?; end
+
+    def pretty_print(q); end
+
+    def requirements; end
+
+    def satisfied_by?(version); end
+
+    def specific?; end
+
+    def to_yaml_properties; end
+
+    def yaml_initialize(tag, vals); end
+
+    def self.create(*inputs); end
+
+    def self.default; end
+
+    def self.parse(obj); end
+
+    def self.source_set; end
+  end
+
+  class Resolver
+    include Gem::Resolver::Molinillo::UI
+    include Gem::Resolver::Molinillo::SpecificationProvider
+    DEBUG_RESOLVER = T.let(nil, T.untyped)
+
+    def activation_request(dep, possible); end
+
+    def development; end
+
+    def development=(development); end
+
+    def development_shallow; end
+
+    def development_shallow=(development_shallow); end
+
+    def explain(stage, *data); end
+
+    def explain_list(stage); end
+
+    def find_possible(dependency); end
+
+    def ignore_dependencies; end
+
+    def ignore_dependencies=(ignore_dependencies); end
+
+    def initialize(needed, set = T.unsafe(nil)); end
+
+    def missing; end
+
+    def requests(s, act, reqs = T.unsafe(nil)); end
+
+    def resolve; end
+
+    def select_local_platforms(specs); end
+
+    def skip_gems; end
+
+    def skip_gems=(skip_gems); end
+
+    def soft_missing; end
+
+    def soft_missing=(soft_missing); end
+
+    def stats; end
+
+    def self.compose_sets(*sets); end
+
+    def self.for_current_gems(needed); end
+
+    def allow_missing?(dependency); end
+
+    def dependencies_for(specification); end
+
+    def name_for(dependency); end
+
+    def name_for_explicit_dependency_source; end
+
+    def name_for_locking_dependency_source; end
+
+    def requirement_satisfied_by?(requirement, activated, spec); end
+
+    def search_for(dependency); end
+
+    def sort_dependencies(dependencies, activated, conflicts); end
+
+    def after_resolution; end
+
+    def before_resolution; end
+
+    def debug(depth = T.unsafe(nil)); end
+
+    def debug?; end
+
+    def indicate_progress; end
+
+    def output; end
+
+    def progress_rate; end
+
+    class APISet
+      def dep_uri; end
+
+      def initialize(dep_uri = T.unsafe(nil)); end
+
+      def prefetch_now; end
+
+      def pretty_print(q); end
+
+      def source; end
+
+      def uri; end
+
+      def versions(name); end
+    end
+
+    class APISpecification
+      def ==(other); end
+
+      def initialize(set, api_data); end
+
+      def pretty_print(q); end
+    end
+
+    class ActivationRequest
+      def ==(other); end
+
+      def development?; end
+
+      def download(path); end
+
+      def full_name; end
+
+      def full_spec; end
+
+      def initialize(spec, request, others_possible = T.unsafe(nil)); end
+
+      def installed?; end
+
+      def name; end
+
+      def others_possible?; end
+
+      def parent; end
+
+      def pretty_print(q); end
+
+      def request; end
+
+      def spec; end
+
+      def version; end
+    end
+
+    class BestSet
+      def initialize(sources = T.unsafe(nil)); end
+
+      def pick_sets; end
+
+      def pretty_print(q); end
+
+      def replace_failed_api_set(error); end
+    end
+
+    class ComposedSet
+      def initialize(*sets); end
+
+      def prerelease=(allow_prerelease); end
+
+      def remote=(remote); end
+
+      def sets; end
+    end
+
+    class Conflict
+      def ==(other); end
+
+      def activated; end
+
+      def conflicting_dependencies; end
+
+      def dependency; end
+
+      def explain; end
+
+      def explanation; end
+
+      def failed_dep; end
+
+      def for_spec?(spec); end
+
+      def initialize(dependency, activated, failed_dep = T.unsafe(nil)); end
+
+      def pretty_print(q); end
+
+      def request_path(current); end
+
+      def requester; end
+    end
+
+    class CurrentSet
+    end
+
+    class DependencyRequest
+      def ==(other); end
+
+      def dependency; end
+
+      def development?; end
+
+      def explicit?; end
+
+      def implicit?; end
+
+      def initialize(dependency, requester); end
+
+      def match?(spec, allow_prerelease = T.unsafe(nil)); end
+
+      def matches_spec?(spec); end
+
+      def name; end
+
+      def pretty_print(q); end
+
+      def request_context; end
+
+      def requester; end
+
+      def requirement; end
+
+      def type; end
+    end
+
+    class GitSet
+      def add_git_gem(name, repository, reference, submodules); end
+
+      def add_git_spec(name, version, repository, reference, submodules); end
+
+      def need_submodules; end
+
+      def pretty_print(q); end
+
+      def repositories; end
+
+      def root_dir; end
+
+      def root_dir=(root_dir); end
+
+      def specs; end
+    end
+
+    class GitSpecification
+      def ==(other); end
+
+      def add_dependency(dependency); end
+
+      def pretty_print(q); end
+    end
+
+    class IndexSet
+      def initialize(source = T.unsafe(nil)); end
+
+      def pretty_print(q); end
+    end
+
+    class IndexSpecification
+      def initialize(set, name, version, source, platform); end
+
+      def pretty_print(q); end
+    end
+
+    class InstalledSpecification
+      def ==(other); end
+
+      def pretty_print(q); end
+    end
+
+    class InstallerSet
+      def add_always_install(dependency); end
+
+      def add_local(dep_name, spec, source); end
+
+      def always_install; end
+
+      def consider_local?; end
+
+      def consider_remote?; end
+
+      def ignore_dependencies; end
+
+      def ignore_dependencies=(ignore_dependencies); end
+
+      def ignore_installed; end
+
+      def ignore_installed=(ignore_installed); end
+
+      def initialize(domain); end
+
+      def load_spec(name, ver, platform, source); end
+
+      def local?(dep_name); end
+
+      def prerelease=(allow_prerelease); end
+
+      def pretty_print(q); end
+
+      def remote=(remote); end
+
+      def remote_set; end
+    end
+
+    class LocalSpecification
+      def pretty_print(q); end
+    end
+
+    class LockSet
+      def add(name, version, platform); end
+
+      def initialize(sources); end
+
+      def load_spec(name, version, platform, source); end
+
+      def pretty_print(q); end
+
+      def specs; end
+    end
+
+    class LockSpecification
+      def add_dependency(dependency); end
+
+      def initialize(set, name, version, sources, platform); end
+
+      def pretty_print(q); end
+
+      def sources; end
+    end
+
+    module Molinillo
+      VERSION = T.let(nil, T.untyped)
+
+      class CircularDependencyError
+        def dependencies; end
+
+        def initialize(nodes); end
+      end
+
+      module Delegates
+        module ResolutionState
+          def activated; end
+
+          def conflicts; end
+
+          def depth; end
+
+          def name; end
+
+          def possibilities; end
+
+          def requirement; end
+
+          def requirements; end
+        end
+
+        module SpecificationProvider
+          def allow_missing?(dependency); end
+
+          def dependencies_for(specification); end
+
+          def name_for(dependency); end
+
+          def name_for_explicit_dependency_source; end
+
+          def name_for_locking_dependency_source; end
+
+          def requirement_satisfied_by?(requirement, activated, spec); end
+
+          def search_for(dependency); end
+
+          def sort_dependencies(dependencies, activated, conflicts); end
+        end
+      end
+
+      class DependencyGraph
+        include Enumerable
+        include TSort
+        Elem = type_member(fixed: T.untyped)
+
+        def ==(other); end
+
+        def add_child_vertex(name, payload, parent_names, requirement); end
+
+        def add_edge(origin, destination, requirement); end
+
+        def add_vertex(name, payload, root = T.unsafe(nil)); end
+
+        def delete_edge(edge); end
+
+        def detach_vertex_named(name); end
+
+        def each(&blk); end
+
+        def log; end
+
+        def rewind_to(tag); end
+
+        def root_vertex_named(name); end
+
+        def set_payload(name, payload); end
+
+        def tag(tag); end
+
+        def to_dot(options = T.unsafe(nil)); end
+
+        def tsort_each_child(vertex, &block); end
+
+        def vertex_named(name); end
+
+        def vertices; end
+
+        def self.tsort(vertices); end
+
+        class Action
+          def down(graph); end
+
+          def next; end
+
+          def next=(_); end
+
+          def previous; end
+
+          def previous=(previous); end
+
+          def up(graph); end
+
+          def self.action_name; end
+        end
+
+        class AddEdgeNoCircular
+          def destination; end
+
+          def initialize(origin, destination, requirement); end
+
+          def make_edge(graph); end
+
+          def origin; end
+
+          def requirement; end
+        end
+
+        class AddVertex
+          def initialize(name, payload, root); end
+
+          def name; end
+
+          def payload; end
+
+          def root; end
+        end
+
+        class DeleteEdge
+          def destination_name; end
+
+          def initialize(origin_name, destination_name, requirement); end
+
+          def make_edge(graph); end
+
+          def origin_name; end
+
+          def requirement; end
+        end
+
+        class DetachVertexNamed
+          def initialize(name); end
+
+          def name; end
+        end
+
+        class Edge
+          def destination; end
+
+          def destination=(_); end
+
+          def origin; end
+
+          def origin=(_); end
+
+          def requirement; end
+
+          def requirement=(_); end
+
+          def self.[](*_); end
+
+          def self.members; end
+        end
+
+        class Log
+          extend T::Enumerable
+          Elem = type_member(fixed: T.untyped)
+
+          def add_edge_no_circular(graph, origin, destination, requirement); end
+
+          def add_vertex(graph, name, payload, root); end
+
+          def delete_edge(graph, origin_name, destination_name, requirement); end
+
+          def detach_vertex_named(graph, name); end
+
+          def each(&blk); end
+
+          def pop!(graph); end
+
+          def reverse_each; end
+
+          def rewind_to(graph, tag); end
+
+          def set_payload(graph, name, payload); end
+
+          def tag(graph, tag); end
+        end
+
+        class SetPayload
+          def initialize(name, payload); end
+
+          def name; end
+
+          def payload; end
+        end
+
+        class Tag
+          def down(_graph); end
+
+          def initialize(tag); end
+
+          def tag; end
+
+          def up(_graph); end
+        end
+
+        class Vertex
+          def ==(other); end
+
+          def ancestor?(other); end
+
+          def descendent?(other); end
+
+          def eql?(other); end
+
+          def explicit_requirements; end
+
+          def incoming_edges; end
+
+          def incoming_edges=(incoming_edges); end
+
+          def initialize(name, payload); end
+
+          def is_reachable_from?(other); end
+
+          def name; end
+
+          def name=(name); end
+
+          def outgoing_edges; end
+
+          def outgoing_edges=(outgoing_edges); end
+
+          def path_to?(other); end
+
+          def payload; end
+
+          def payload=(payload); end
+
+          def predecessors; end
+
+          def recursive_predecessors; end
+
+          def recursive_successors; end
+
+          def requirements; end
+
+          def root; end
+
+          def root=(root); end
+
+          def root?; end
+
+          def shallow_eql?(other); end
+
+          def successors; end
+        end
+      end
+
+      class DependencyState
+        def pop_possibility_state; end
+      end
+
+      class NoSuchDependencyError
+        def dependency; end
+
+        def dependency=(dependency); end
+
+        def initialize(dependency, required_by = T.unsafe(nil)); end
+
+        def required_by; end
+
+        def required_by=(required_by); end
+      end
+
+      class PossibilityState
+      end
+
+      class ResolutionState
+        def activated; end
+
+        def activated=(_); end
+
+        def conflicts; end
+
+        def conflicts=(_); end
+
+        def depth; end
+
+        def depth=(_); end
+
+        def name; end
+
+        def name=(_); end
+
+        def possibilities; end
+
+        def possibilities=(_); end
+
+        def requirement; end
+
+        def requirement=(_); end
+
+        def requirements; end
+
+        def requirements=(_); end
+
+        def self.[](*_); end
+
+        def self.empty; end
+
+        def self.members; end
+      end
+
+      class Resolver
+        def initialize(specification_provider, resolver_ui); end
+
+        def resolve(requested, base = T.unsafe(nil)); end
+
+        def resolver_ui; end
+
+        def specification_provider; end
+
+        class Resolution
+          include Gem::Resolver::Molinillo::Delegates::ResolutionState
+          include Gem::Resolver::Molinillo::Delegates::SpecificationProvider
+
+          def base; end
+
+          def initialize(specification_provider, resolver_ui, requested, base); end
+
+          def iteration_rate=(iteration_rate); end
+
+          def original_requested; end
+
+          def resolve; end
+
+          def resolver_ui; end
+
+          def specification_provider; end
+
+          def started_at=(started_at); end
+
+          def states=(states); end
+
+          def allow_missing?(dependency); end
+
+          def dependencies_for(specification); end
+
+          def name_for(dependency); end
+
+          def name_for_explicit_dependency_source; end
+
+          def name_for_locking_dependency_source; end
+
+          def requirement_satisfied_by?(requirement, activated, spec); end
+
+          def search_for(dependency); end
+
+          def sort_dependencies(dependencies, activated, conflicts); end
+
+          def activated; end
+
+          def conflicts; end
+
+          def depth; end
+
+          def name; end
+
+          def possibilities; end
+
+          def requirement; end
+
+          def requirements; end
+
+          class Conflict
+            def activated_by_name; end
+
+            def activated_by_name=(_); end
+
+            def existing; end
+
+            def existing=(_); end
+
+            def locked_requirement; end
+
+            def locked_requirement=(_); end
+
+            def possibility; end
+
+            def possibility=(_); end
+
+            def requirement; end
+
+            def requirement=(_); end
+
+            def requirement_trees; end
+
+            def requirement_trees=(_); end
+
+            def requirements; end
+
+            def requirements=(_); end
+
+            def self.[](*_); end
+
+            def self.members; end
+          end
+        end
+      end
+
+      class ResolverError
+      end
+
+      module SpecificationProvider
+        def allow_missing?(dependency); end
+
+        def dependencies_for(specification); end
+
+        def name_for(dependency); end
+
+        def name_for_explicit_dependency_source; end
+
+        def name_for_locking_dependency_source; end
+
+        def requirement_satisfied_by?(requirement, activated, spec); end
+
+        def search_for(dependency); end
+
+        def sort_dependencies(dependencies, activated, conflicts); end
+      end
+
+      module UI
+        def after_resolution; end
+
+        def before_resolution; end
+
+        def debug(depth = T.unsafe(nil)); end
+
+        def debug?; end
+
+        def indicate_progress; end
+
+        def output; end
+
+        def progress_rate; end
+      end
+
+      class VersionConflict
+        def conflicts; end
+
+        def initialize(conflicts); end
+      end
+    end
+
+    class RequirementList
+      include Enumerable
+      Elem = type_member(fixed: T.untyped)
+
+      def add(req); end
+
+      def each(&blk); end
+
+      def empty?; end
+
+      def next5; end
+
+      def remove; end
+
+      def size; end
+    end
+
+    class Set
+      def errors; end
+
+      def errors=(errors); end
+
+      def find_all(req); end
+
+      def prefetch(reqs); end
+
+      def prerelease; end
+
+      def prerelease=(prerelease); end
+
+      def remote; end
+
+      def remote=(remote); end
+
+      def remote?; end
+    end
+
+    class SourceSet
+      def add_source_gem(name, source); end
+    end
+
+    class SpecSpecification
+      def initialize(set, spec, source = T.unsafe(nil)); end
+    end
+
+    class Specification
+      def dependencies; end
+
+      def download(options); end
+
+      def fetch_development_dependencies; end
+
+      def full_name; end
+
+      def install(options = T.unsafe(nil)); end
+
+      def installable_platform?; end
+
+      def local?; end
+
+      def name; end
+
+      def platform; end
+
+      def set; end
+
+      def source; end
+
+      def spec; end
+
+      def version; end
+    end
+
+    class Stats
+      PATTERN = T.let(nil, T.untyped)
+
+      def backtracking!; end
+
+      def display; end
+
+      def iteration!; end
+
+      def record_depth(stack); end
+
+      def record_requirements(reqs); end
+
+      def requirement!; end
+    end
+
+    class VendorSet
+      def add_vendor_gem(name, directory); end
+
+      def load_spec(name, version, platform, source); end
+
+      def pretty_print(q); end
+
+      def specs; end
+    end
+
+    class VendorSpecification
+      def ==(other); end
+    end
+  end
+
+  class RuntimeRequirementNotMetError
+    def suggestion; end
+
+    def suggestion=(suggestion); end
+  end
+
+  module Security
+    AlmostNoSecurity = T.let(nil, T.untyped)
+    DIGEST_NAME = T.let(nil, T.untyped)
+    EXTENSIONS = T.let(nil, T.untyped)
+    HighSecurity = T.let(nil, T.untyped)
+    KEY_CIPHER = T.let(nil, T.untyped)
+    KEY_LENGTH = T.let(nil, T.untyped)
+    LowSecurity = T.let(nil, T.untyped)
+    MediumSecurity = T.let(nil, T.untyped)
+    NoSecurity = T.let(nil, T.untyped)
+    ONE_DAY = T.let(nil, T.untyped)
+    ONE_YEAR = T.let(nil, T.untyped)
+    Policies = T.let(nil, T.untyped)
+    SigningPolicy = T.let(nil, T.untyped)
+
+    def self.alt_name_or_x509_entry(certificate, x509_entry); end
+
+    def self.create_cert(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
+
+    def self.create_cert_email(email, key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end
+
+    def self.create_cert_self_signed(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
+
+    def self.create_key(length = T.unsafe(nil), algorithm = T.unsafe(nil)); end
+
+    def self.email_to_name(email_address); end
+
+    def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end
+
+    def self.reset; end
+
+    def self.sign(certificate, signing_key, signing_cert, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
+
+    def self.trust_dir; end
+
+    def self.trusted_certificates(&block); end
+
+    def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end
+
+    class DIGEST_ALGORITHM
+      def initialize(data = T.unsafe(nil)); end
+
+      def self.digest(data); end
+
+      def self.hexdigest(data); end
+    end
+
+    class Exception
+    end
+
+    class KEY_ALGORITHM
+      NO_PADDING = T.let(nil, T.untyped)
+      PKCS1_OAEP_PADDING = T.let(nil, T.untyped)
+      PKCS1_PADDING = T.let(nil, T.untyped)
+      SSLV23_PADDING = T.let(nil, T.untyped)
+
+      def d; end
+
+      def d=(d); end
+
+      def dmp1; end
+
+      def dmp1=(dmp1); end
+
+      def dmq1; end
+
+      def dmq1=(dmq1); end
+
+      def e; end
+
+      def e=(e); end
+
+      def export(*_); end
+
+      def initialize(*_); end
+
+      def iqmp; end
+
+      def iqmp=(iqmp); end
+
+      def n; end
+
+      def n=(n); end
+
+      def p; end
+
+      def p=(p); end
+
+      def params; end
+
+      def private?; end
+
+      def private_decrypt(*_); end
+
+      def private_encrypt(*_); end
+
+      def public?; end
+
+      def public_decrypt(*_); end
+
+      def public_encrypt(*_); end
+
+      def public_key; end
+
+      def q; end
+
+      def q=(q); end
+
+      def set_crt_params(_, _1, _2); end
+
+      def set_factors(_, _1); end
+
+      def set_key(_, _1, _2); end
+
+      def sign_pss(*_); end
+
+      def to_der; end
+
+      def to_pem(*_); end
+
+      def to_s(*_); end
+
+      def to_text; end
+
+      def verify_pss(*_); end
+
+      def self.generate(*_); end
+    end
+
+    class Policy
+      include Gem::UserInteraction
+      include Gem::DefaultUserInteraction
+      include Gem::Text
+
+      def check_cert(signer, issuer, time); end
+
+      def check_chain(chain, time); end
+
+      def check_data(public_key, digest, signature, data); end
+
+      def check_key(signer, key); end
+
+      def check_root(chain, time); end
+
+      def check_trust(chain, digester, trust_dir); end
+
+      def initialize(name, policy = T.unsafe(nil), opt = T.unsafe(nil)); end
+
+      def name; end
+
+      def only_signed; end
+
+      def only_signed=(only_signed); end
+
+      def only_trusted; end
+
+      def only_trusted=(only_trusted); end
+
+      def subject(certificate); end
+
+      def verify(chain, key = T.unsafe(nil), digests = T.unsafe(nil), signatures = T.unsafe(nil), full_name = T.unsafe(nil)); end
+
+      def verify_chain; end
+
+      def verify_chain=(verify_chain); end
+
+      def verify_data; end
+
+      def verify_data=(verify_data); end
+
+      def verify_root; end
+
+      def verify_root=(verify_root); end
+
+      def verify_signatures(spec, digests, signatures); end
+
+      def verify_signer; end
+
+      def verify_signer=(verify_signer); end
+
+      def clean_text(text); end
+
+      def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+      def levenshtein_distance(str1, str2); end
+
+      def min3(a, b, c); end
+
+      def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+      def ui; end
+
+      def ui=(new_ui); end
+
+      def use_ui(new_ui, &block); end
+
+      def alert(statement, question = T.unsafe(nil)); end
+
+      def alert_error(statement, question = T.unsafe(nil)); end
+
+      def alert_warning(statement, question = T.unsafe(nil)); end
+
+      def ask(question); end
+
+      def ask_for_password(prompt); end
+
+      def ask_yes_no(question, default = T.unsafe(nil)); end
+
+      def choose_from_list(question, list); end
+
+      def say(statement = T.unsafe(nil)); end
+
+      def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+      def verbose(msg = T.unsafe(nil)); end
+    end
+
+    class Signer
+      include Gem::UserInteraction
+      include Gem::DefaultUserInteraction
+      include Gem::Text
+      DEFAULT_OPTIONS = T.let(nil, T.untyped)
+
+      def cert_chain; end
+
+      def cert_chain=(cert_chain); end
+
+      def digest_algorithm; end
+
+      def digest_name; end
+
+      def extract_name(cert); end
+
+      def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end
+
+      def key; end
+
+      def key=(key); end
+
+      def load_cert_chain; end
+
+      def options; end
+
+      def re_sign_key(expiration_length: T.unsafe(nil)); end
+
+      def sign(data); end
+
+      def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
+
+      def clean_text(text); end
+
+      def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+      def levenshtein_distance(str1, str2); end
+
+      def min3(a, b, c); end
+
+      def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+      def ui; end
+
+      def ui=(new_ui); end
+
+      def use_ui(new_ui, &block); end
+
+      def alert(statement, question = T.unsafe(nil)); end
+
+      def alert_error(statement, question = T.unsafe(nil)); end
+
+      def alert_warning(statement, question = T.unsafe(nil)); end
+
+      def ask(question); end
+
+      def ask_for_password(prompt); end
+
+      def ask_yes_no(question, default = T.unsafe(nil)); end
+
+      def choose_from_list(question, list); end
+
+      def say(statement = T.unsafe(nil)); end
+
+      def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+      def verbose(msg = T.unsafe(nil)); end
+    end
+
+    class TrustDir
+      DEFAULT_PERMISSIONS = T.let(nil, T.untyped)
+
+      def cert_path(certificate); end
+
+      def dir; end
+
+      def each_certificate; end
+
+      def initialize(dir, permissions = T.unsafe(nil)); end
+
+      def issuer_of(certificate); end
+
+      def load_certificate(certificate_file); end
+
+      def name_path(name); end
+
+      def trust_cert(certificate); end
+
+      def verify; end
+    end
+  end
+
+  class SilentUI
+    def initialize; end
+  end
+
+  class Source
+    include Comparable
+    FILES = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def cache_dir(uri); end
+
+    def dependency_resolver_set; end
+
+    def download(spec, dir = T.unsafe(nil)); end
+
+    def eql?(other); end
+
+    def fetch_spec(name_tuple); end
+
+    def initialize(uri); end
+
+    def load_specs(type); end
+
+    def pretty_print(q); end
+
+    def update_cache?; end
+
+    def uri; end
+
+    class Git
+      def base_dir; end
+
+      def cache; end
+
+      def checkout; end
+
+      def dir_shortref; end
+
+      def download(full_spec, path); end
+
+      def initialize(name, repository, reference, submodules = T.unsafe(nil)); end
+
+      def install_dir; end
+
+      def name; end
+
+      def need_submodules; end
+
+      def reference; end
+
+      def remote; end
+
+      def remote=(remote); end
+
+      def repo_cache_dir; end
+
+      def repository; end
+
+      def rev_parse; end
+
+      def root_dir; end
+
+      def root_dir=(root_dir); end
+
+      def specs; end
+
+      def uri_hash; end
+    end
+
+    class Installed
+      def download(spec, path); end
+
+      def initialize; end
+    end
+
+    class Local
+      def download(spec, cache_dir = T.unsafe(nil)); end
+
+      def fetch_spec(name); end
+
+      def find_gem(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end
+
+      def initialize; end
+    end
+
+    class Lock
+      def initialize(source); end
+
+      def wrapped; end
+    end
+
+    class SpecificFile
+      def fetch_spec(name); end
+
+      def initialize(file); end
+
+      def load_specs(*a); end
+
+      def path; end
+
+      def spec; end
+    end
+
+    class Vendor
+      def initialize(path); end
+    end
+  end
+
+  class SourceFetchProblem
+    def error; end
+
+    def exception; end
+
+    def initialize(source, error); end
+
+    def source; end
+
+    def wordy; end
+  end
+
+  class SourceList
+    include Enumerable
+    Elem = type_member(fixed: T.untyped)
+
+    def <<(obj); end
+
+    def ==(other); end
+
+    def clear; end
+
+    def delete(source); end
+
+    def each(&blk); end
+
+    def each_source(&b); end
+
+    def empty?; end
+
+    def first; end
+
+    def include?(other); end
+
+    def replace(other); end
+
+    def sources; end
+
+    def to_a; end
+
+    def to_ary; end
+
+    def self.from(ary); end
+  end
+
+  class SpecFetcher
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+
+    def available_specs(type); end
+
+    def detect(type = T.unsafe(nil)); end
+
+    def initialize(sources = T.unsafe(nil)); end
+
+    def latest_specs; end
+
+    def prerelease_specs; end
+
+    def search_for_dependency(dependency, matching_platform = T.unsafe(nil)); end
+
+    def sources; end
+
+    def spec_for_dependency(dependency, matching_platform = T.unsafe(nil)); end
+
+    def specs; end
+
+    def suggest_gems_from_name(gem_name, type = T.unsafe(nil)); end
+
+    def tuples_for(source, type, gracefully_ignore = T.unsafe(nil)); end
+
+    def self.fetcher; end
+
+    def self.fetcher=(fetcher); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class SpecificGemNotFoundException
+    def errors; end
+
+    def initialize(name, version, errors = T.unsafe(nil)); end
+
+    def name; end
+
+    def version; end
+  end
+
+  class Specification
+    include Bundler::MatchPlatform
+    include Bundler::GemHelpers
+    extend Gem::Deprecate
+    DateLike = T.let(nil, T.untyped)
+    DateTimeFormat = T.let(nil, T.untyped)
+    INITIALIZE_CODE_FOR_DEFAULTS = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def _deprecated_default_executable; end
+
+    def _deprecated_default_executable=(_deprecated_default_executable); end
+
+    def _deprecated_has_rdoc; end
+
+    def _deprecated_has_rdoc=(ignored); end
+
+    def _deprecated_has_rdoc?(*args, &block); end
+
+    def _dump(limit); end
+
+    def abbreviate; end
+
+    def activate; end
+
+    def activate_dependencies; end
+
+    def activated; end
+
+    def activated=(activated); end
+
+    def add_bindir(executables); end
+
+    def add_dependency(gem, *requirements); end
+
+    def add_development_dependency(gem, *requirements); end
+
+    def add_runtime_dependency(gem, *requirements); end
+
+    def add_self_to_load_path; end
+
+    def author; end
+
+    def author=(o); end
+
+    def authors; end
+
+    def authors=(value); end
+
+    def autorequire; end
+
+    def autorequire=(autorequire); end
+
+    def bin_dir; end
+
+    def bin_file(name); end
+
+    def bindir; end
+
+    def bindir=(bindir); end
+
+    def build_args; end
+
+    def build_extensions; end
+
+    def build_info_dir; end
+
+    def build_info_file; end
+
+    def cache_dir; end
+
+    def cache_file; end
+
+    def cert_chain; end
+
+    def cert_chain=(cert_chain); end
+
+    def conficts_when_loaded_with?(list_of_specs); end
+
+    def conflicts; end
+
+    def date; end
+
+    def date=(date); end
+
+    def default_executable(*args, &block); end
+
+    def default_executable=(*args, &block); end
+
+    def default_value(name); end
+
+    def dependencies; end
+
+    def dependent_gems; end
+
+    def dependent_specs; end
+
+    def description; end
+
+    def description=(str); end
+
+    def development_dependencies; end
+
+    def doc_dir(type = T.unsafe(nil)); end
+
+    def email; end
+
+    def email=(email); end
+
+    def encode_with(coder); end
+
+    def eql?(other); end
+
+    def executable; end
+
+    def executable=(o); end
+
+    def executables; end
+
+    def executables=(value); end
+
+    def extensions; end
+
+    def extensions=(extensions); end
+
+    def extra_rdoc_files; end
+
+    def extra_rdoc_files=(files); end
+
+    def file_name; end
+
+    def files; end
+
+    def files=(files); end
+
+    def for_cache; end
+
+    def git_version; end
+
+    def groups; end
+
+    def has_conflicts?; end
+
+    def has_rdoc(*args, &block); end
+
+    def has_rdoc=(*args, &block); end
+
+    def has_rdoc?(*args, &block); end
+
+    def has_test_suite?; end
+
+    def has_unit_tests?; end
+
+    def homepage; end
+
+    def homepage=(homepage); end
+
+    def init_with(coder); end
+
+    def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end
+
+    def installed_by_version; end
+
+    def installed_by_version=(version); end
+
+    def keep_only_files_and_directories; end
+
+    def lib_files; end
+
+    def license; end
+
+    def license=(o); end
+
+    def licenses; end
+
+    def licenses=(licenses); end
+
+    def load_paths; end
+
+    def location; end
+
+    def location=(location); end
+
+    def mark_version; end
+
+    def metadata; end
+
+    def metadata=(metadata); end
+
+    def method_missing(sym, *a, &b); end
+
+    def missing_extensions?; end
+
+    def name=(name); end
+
+    def name_tuple; end
+
+    def nondevelopment_dependencies; end
+
+    def normalize; end
+
+    def original_name; end
+
+    def original_platform; end
+
+    def original_platform=(original_platform); end
+
+    def platform=(platform); end
+
+    def post_install_message; end
+
+    def post_install_message=(post_install_message); end
+
+    def pretty_print(q); end
+
+    def raise_if_conflicts; end
+
+    def rdoc_options; end
+
+    def rdoc_options=(options); end
+
+    def relative_loaded_from; end
+
+    def relative_loaded_from=(relative_loaded_from); end
+
+    def remote; end
+
+    def remote=(remote); end
+
+    def require_path; end
+
+    def require_path=(path); end
+
+    def require_paths=(val); end
+
+    def required_ruby_version; end
+
+    def required_ruby_version=(req); end
+
+    def required_rubygems_version; end
+
+    def required_rubygems_version=(req); end
+
+    def requirements; end
+
+    def requirements=(req); end
+
+    def reset_nil_attributes_to_default; end
+
+    def rg_extension_dir; end
+
+    def rg_full_gem_path; end
+
+    def rg_loaded_from; end
+
+    def ri_dir; end
+
+    def rubyforge_project=(rubyforge_project); end
+
+    def rubygems_version; end
+
+    def rubygems_version=(rubygems_version); end
+
+    def runtime_dependencies; end
+
+    def sanitize; end
+
+    def sanitize_string(string); end
+
+    def satisfies_requirement?(dependency); end
+
+    def signing_key; end
+
+    def signing_key=(signing_key); end
+
+    def sort_obj; end
+
+    def source; end
+
+    def source=(source); end
+
+    def spec_dir; end
+
+    def spec_file; end
+
+    def spec_name; end
+
+    def specification_version; end
+
+    def specification_version=(specification_version); end
+
+    def summary; end
+
+    def summary=(str); end
+
+    def test_file; end
+
+    def test_file=(file); end
+
+    def test_files; end
+
+    def test_files=(files); end
+
+    def to_gemfile(path = T.unsafe(nil)); end
+
+    def to_ruby; end
+
+    def to_ruby_for_cache; end
+
+    def to_yaml(opts = T.unsafe(nil)); end
+
+    def traverse(trail = T.unsafe(nil), visited = T.unsafe(nil), &block); end
+
+    def validate(packaging = T.unsafe(nil), strict = T.unsafe(nil)); end
+
+    def validate_dependencies; end
+
+    def validate_metadata; end
+
+    def validate_permissions; end
+
+    def version=(version); end
+
+    def yaml_initialize(tag, vals); end
+
+    def self._all; end
+
+    def self._clear_load_cache; end
+
+    def self._latest_specs(specs, prerelease = T.unsafe(nil)); end
+
+    def self._load(str); end
+
+    def self._resort!(specs); end
+
+    def self.add_spec(spec); end
+
+    def self.add_specs(*specs); end
+
+    def self.all; end
+
+    def self.all=(specs); end
+
+    def self.all_names; end
+
+    def self.array_attributes; end
+
+    def self.attribute_names; end
+
+    def self.dirs; end
+
+    def self.dirs=(dirs); end
+
+    def self.each(&blk); end
+
+    def self.each_gemspec(dirs); end
+
+    def self.each_spec(dirs); end
+
+    def self.find_active_stub_by_path(path); end
+
+    def self.find_all_by_full_name(full_name); end
+
+    def self.find_all_by_name(name, *requirements); end
+
+    def self.find_by_name(name, *requirements); end
+
+    def self.find_by_path(path); end
+
+    def self.find_in_unresolved(path); end
+
+    def self.find_in_unresolved_tree(path); end
+
+    def self.find_inactive_by_path(path); end
+
+    def self.from_yaml(input); end
+
+    def self.latest_specs(prerelease = T.unsafe(nil)); end
+
+    def self.load(file); end
+
+    def self.load_defaults; end
+
+    def self.non_nil_attributes; end
+
+    def self.normalize_yaml_input(input); end
+
+    def self.outdated; end
+
+    def self.outdated_and_latest_version; end
+
+    def self.remove_spec(spec); end
+
+    def self.required_attribute?(name); end
+
+    def self.required_attributes; end
+
+    def self.reset; end
+
+    def self.stubs; end
+
+    def self.stubs_for(name); end
+
+    def self.unresolved_deps; end
+  end
+
+  class SpecificationPolicy
+    HOMEPAGE_URI_PATTERN = T.let(nil, T.untyped)
+    LAZY = T.let(nil, T.untyped)
+    LAZY_PATTERN = T.let(nil, T.untyped)
+    METADATA_LINK_KEYS = T.let(nil, T.untyped)
+    SPECIAL_CHARACTERS = T.let(nil, T.untyped)
+    VALID_NAME_PATTERN = T.let(nil, T.untyped)
+    VALID_URI_PATTERN = T.let(nil, T.untyped)
+
+    def initialize(specification); end
+
+    def packaging; end
+
+    def packaging=(packaging); end
+
+    def validate(strict = T.unsafe(nil)); end
+
+    def validate_dependencies; end
+
+    def validate_metadata; end
+
+    def validate_permissions; end
+  end
+
+  class StreamUI
+    extend Gem::Deprecate
+
+    def _deprecated_debug(statement); end
+
+    def _gets_noecho; end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(question); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def backtrace(exception); end
+
+    def choose_from_list(question, list); end
+
+    def close; end
+
+    def debug(*args, &block); end
+
+    def download_reporter(*args); end
+
+    def errs; end
+
+    def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end
+
+    def ins; end
+
+    def outs; end
+
+    def progress_reporter(*args); end
+
+    def require_io_console; end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(status = T.unsafe(nil)); end
+
+    def tty?; end
+  end
+
+  class StubSpecification
+    def build_extensions; end
+
+    def extensions; end
+
+    def initialize(filename, base_dir, gems_dir, default_gem); end
+
+    def missing_extensions?; end
+
+    def valid?; end
+
+    def self.default_gemspec_stub(filename, base_dir, gems_dir); end
+
+    def self.gemspec_stub(filename, base_dir, gems_dir); end
+
+    class StubLine
+      def extensions; end
+
+      def full_name; end
+
+      def initialize(data, extensions); end
+
+      def name; end
+
+      def platform; end
+
+      def require_paths; end
+
+      def version; end
+    end
+  end
+
+  class SystemExitException
+    def exit_code; end
+
+    def exit_code=(exit_code); end
+
+    def initialize(exit_code); end
+  end
+
+  module Text
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+  end
+
+  class UninstallError
+    def spec; end
+
+    def spec=(spec); end
+  end
+
+  class UnsatisfiableDependencyError
+    def dependency; end
+
+    def errors; end
+
+    def errors=(errors); end
+
+    def initialize(dep, platform_mismatch = T.unsafe(nil)); end
+
+    def name; end
+
+    def version; end
+  end
+
+  class UriFormatter
+    def escape; end
+
+    def initialize(uri); end
+
+    def normalize; end
+
+    def unescape; end
+
+    def uri; end
+  end
+
+  module UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+  end
+
+  module Util
+    def self.glob_files_in_dir(glob, base_path); end
+
+    def self.gunzip(data); end
+
+    def self.gzip(data); end
+
+    def self.inflate(data); end
+
+    def self.popen(*command); end
+
+    def self.silent_system(*command); end
+
+    def self.traverse_parents(directory, &block); end
+  end
+
+  class Version
+    def _segments; end
+
+    def _split_segments; end
+
+    def _version; end
+
+    def approximate_recommendation; end
+
+    def bump; end
+
+    def canonical_segments; end
+
+    def encode_with(coder); end
+
+    def eql?(other); end
+
+    def init_with(coder); end
+
+    def marshal_dump; end
+
+    def marshal_load(array); end
+
+    def prerelease?; end
+
+    def pretty_print(q); end
+
+    def release; end
+
+    def segments; end
+
+    def to_yaml_properties; end
+
+    def version; end
+
+    def yaml_initialize(tag, map); end
+
+    def self.correct?(version); end
+
+    def self.create(input); end
+
+    def self.new(version); end
+  end
+end
+
+Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
+Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_
+Gem::Version::Requirement = Gem::Requirement
+Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict
diff --git a/_base/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi b/base/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
similarity index 71%
rename from _base/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
rename to base/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
index 0948980..ad90816 100644
--- a/_base/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
+++ b/base/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
@@ -12,8 +12,8 @@ module Open3
     params(
       cmd: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Thread).void
-    ).returns([IO, IO, IO, Thread])
+      block: T.nilable(T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter).void)
+    ).returns([IO, IO, IO, Process::Waiter])
   end
   def self.popen3(*cmd, **opts, &block); end
 
@@ -21,8 +21,8 @@ module Open3
     params(
       cmd: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(stdin: IO, stdout: IO, wait_thr: Thread).void
-    ).returns([IO, IO, Thread])
+      block: T.nilable(T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter).void)
+    ).returns([IO, IO, Process::Waiter])
   end
   def self.popen2(*cmd, **opts, &block); end
 
@@ -30,8 +30,8 @@ module Open3
     params(
       cmd: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(stdin: IO, stdout_and_stderr: IO, wait_thr: Thread).void
-    ).returns([IO, IO, Thread])
+      block: T.nilable(T.proc.params(stdin: IO, stdout_and_stderr: IO, wait_thr: Process::Waiter).void)
+    ).returns([IO, IO, Process::Waiter])
   end
   def self.popen2e(*cmd, **opts, &block); end
 
@@ -69,8 +69,8 @@ module Open3
     params(
       cmds: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(first_stdin: IO, last_stdout: IO, wait_threads: T::Array[Thread]).void
-    ).returns([IO, IO, T::Array[Thread]])
+      block: T.nilable(T.proc.params(first_stdin: IO, last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void)
+    ).returns([IO, IO, T::Array[Process::Waiter]])
   end
   def self.pipeline_rw(*cmds, **opts, &block); end
 
@@ -78,8 +78,8 @@ module Open3
     params(
       cmds: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(last_stdout: IO, wait_threads: T::Array[Thread]).void
-    ).returns([IO, T::Array[Thread]])
+      block: T.nilable(T.proc.params(last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void)
+    ).returns([IO, T::Array[Process::Waiter]])
   end
   def self.pipeline_r(*cmds, **opts, &block); end
 
@@ -87,8 +87,8 @@ module Open3
     params(
       cmds: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(first_stdin: IO, wait_threads: T::Array[Thread]).void
-    ).returns([IO, T::Array[Thread]])
+      block: T.nilable(T.proc.params(first_stdin: IO, wait_threads: T::Array[Process::Waiter]).void)
+    ).returns([IO, T::Array[Process::Waiter]])
   end
   def self.pipeline_w(*cmds, **opts, &block); end
 
@@ -96,8 +96,8 @@ module Open3
     params(
       cmds: T.any(String, T::Array[String]),
       opts: T::Hash[Symbol, T.untyped],
-      block: T.proc.params(wait_threads: T::Array[Thread]).void
-    ).returns(T::Array[Thread])
+      block: T.nilable(T.proc.params(wait_threads: T::Array[Process::Waiter]).void)
+    ).returns(T::Array[Process::Waiter])
   end
   def self.pipeline_start(*cmds, **opts, &block); end
 
diff --git a/_base/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi b/base/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
similarity index 99%
rename from _base/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
rename to base/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
index 9c1b057..3429695 100644
--- a/_base/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
+++ b/base/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
@@ -523,7 +523,7 @@ class Resolv
     end
 
     class Alt
-      Regex = Regex = T.let(T.unsafe(nil), Regexp)
+      Regex = T.let(T.unsafe(nil), Regexp)
 
       sig { params(arg: T.any(String, Resolv::LOC::Alt)).returns(Resolv::LOC::Alt) }
       def self.create(arg); end
diff --git a/_base/sorbet/rbi/todo.rbi b/base/sorbet/rbi/todo.rbi
similarity index 100%
rename from _base/sorbet/rbi/todo.rbi
rename to base/sorbet/rbi/todo.rbi
diff --git a/bin/docker-compose-up b/bin/compose-up-all
similarity index 67%
rename from bin/docker-compose-up
rename to bin/compose-up-all
index 775a455..86d0993 100755
--- a/bin/docker-compose-up
+++ b/bin/compose-up-all
@@ -3,5 +3,5 @@
 system("bin/build && docker-compose build --compress --parallel")
 
 File.read("SERVICES").split("\n").each do |name|
-  system("docker-compose --compatibility up #{name}")
+  exit(1) unless system("docker-compose --compatibility up #{name}")
 end
diff --git a/bin/docker-build b/bin/docker-build
index a90f049..70acfde 100755
--- a/bin/docker-build
+++ b/bin/docker-build
@@ -6,7 +6,7 @@ docker build \
   --cache-from us.gcr.io/$1/base:latest \
   --tag us.gcr.io/$1/base:latest \
   --tag us.gcr.io/$1/base:$2 \
-  _base
+  base
 
 if [ $3 ]
   then
diff --git a/bin/docker-build-ci b/bin/docker-build-ci
new file mode 100755
index 0000000..698cda0
--- /dev/null
+++ b/bin/docker-build-ci
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+docker build \
+  --tag us.gcr.io/farsight-239605/base:latest \
+  base
+
+if [ $1 ]
+  then
+  docker build \
+    $1
+fi
diff --git a/bin/docker-build-development b/bin/docker-build-development
index 3ae62e4..0f48455 100755
--- a/bin/docker-build-development
+++ b/bin/docker-build-development
@@ -5,7 +5,7 @@ set -e
 docker build \
   --cache-from us.gcr.io/farsight-239605/base:latest \
   --tag us.gcr.io/farsight-239605/base:`git rev-parse --short HEAD 2> /dev/null` \
-  _base
+  base
 
 if [ $1 ]
   then
diff --git a/bin/gcloud-cloudbuild-create b/bin/gcloud-cloudbuild-create-all
similarity index 95%
rename from bin/gcloud-cloudbuild-create
rename to bin/gcloud-cloudbuild-create-all
index 2ec4c63..aad2176 100755
--- a/bin/gcloud-cloudbuild-create
+++ b/bin/gcloud-cloudbuild-create-all
@@ -25,7 +25,7 @@ File.read("SERVICES").split("\n").each do |name|
       "_SERVICE_ID" => name
     },
     description: "Push to master branch (#{name})",
-    filename: "_gcloud/cloudbuild.yaml"
+    filename: ".gcloud/cloudbuild.yaml"
   })
 
   response = http.request(request)
diff --git a/bin/local b/bin/local
index c5b7238..13010c1 100755
--- a/bin/local
+++ b/bin/local
@@ -5,7 +5,6 @@ set -e
 service=$1
 shift
 
-
 [ -z "$service" ] && echo "You have to specify the service" && exit 126
 
 echo "[$service] $@"
diff --git a/bin/local-check b/bin/local-check
deleted file mode 100755
index 9cdece8..0000000
--- a/bin/local-check
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-File.read("SERVICES").split("\n").each do |name|
-  puts "Creating links for #{name}/..."
-  system("bin/local-lint #{name}")
-  system("bin/local #{name} bundle exec srb tc")
-end
diff --git a/bin/local-check-all b/bin/local-check-all
new file mode 100755
index 0000000..0f168bf
--- /dev/null
+++ b/bin/local-check-all
@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+File.read("SERVICES").split("\n").each do |name|
+  puts "Checking for errors in #{name}..."
+  exit(1) unless system("bin/local-lint #{name}")
+  exit(1) unless system("bin/local-typecheck #{name}")
+end
\ No newline at end of file
diff --git a/bin/local-each b/bin/local-each
new file mode 100755
index 0000000..64bea5a
--- /dev/null
+++ b/bin/local-each
@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+File.read("SERVICES").split("\n").each do |name|
+  exit(1) unless system("#{ARGV[0]} #{name}")
+end
diff --git a/bin/local-link b/bin/local-link
deleted file mode 100755
index c475afa..0000000
--- a/bin/local-link
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-
-File.read("SERVICES").split("\n").each do |name|
-  puts "Creating links for #{name}/..."
-  system("bin/local #{name} ln -svfF ../_base/db/ .  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/.rubocop/ .  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/sorbet/ .  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../.tool-versions  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/Gemfile  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/Gemfile.lock  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/boot.rb  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/mocks.rb  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/config.ru  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/configuration.rb  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/application.rb  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/database.rb  &>/dev/null")
-  system("bin/local #{name} ln -svfF ../_base/Rakefile  &>/dev/null")
-end
diff --git a/bin/local-link-all b/bin/local-link-all
new file mode 100755
index 0000000..426f2b4
--- /dev/null
+++ b/bin/local-link-all
@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+File.read("SERVICES").split("\n").each do |name|
+  puts "Creating links for #{name}/..."
+  exit(1) unless system("bin/local #{name} ln -svfF ../.tool-versions  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/db/ .  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/middleware/ .  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/.rubocop/ .  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/sorbet/ .  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/Gemfile  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/Gemfile.lock  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/boot.rb  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/mocks.rb  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/config.ru  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/configuration.rb  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/application.rb  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/database.rb  &>/dev/null")
+  exit(1) unless system("bin/local #{name} ln -svfF ../base/Rakefile  &>/dev/null")
+end
diff --git a/bin/local-pry b/bin/local-pry
index 1e600c7..ae035dd 100755
--- a/bin/local-pry
+++ b/bin/local-pry
@@ -4,7 +4,7 @@ set -e
 
 service=$1
 
-bin/local $service bundle exec pry \
+CONSOLE=yes bin/local $service bundle exec pry \
   --require "./boot" \
   --require "./configuration" \
   --require "./application" \
diff --git a/bin/local-psql b/bin/local-psql
index 4a82963..05bb5f5 100755
--- a/bin/local-psql
+++ b/bin/local-psql
@@ -2,4 +2,4 @@
 
 set -e
 
-psql 'postgresql://gitpod:@localhost/resources'
+psql 'postgresql://postgres:@localhost/resources'
diff --git a/bin/local-run b/bin/local-run
index 62b2254..550b4ba 100755
--- a/bin/local-run
+++ b/bin/local-run
@@ -4,7 +4,7 @@ set -e
 
 service=$1
 
-echo "function(request: MOCK_REQUEST, response: MOCK_RESPONSE, database: DATABASE)" | bin/local $service bundle exec ruby \
+echo "function(request: MOCK_REQUEST, database: DATABASE, logger: Async.logger)" | bin/local $service bundle exec ruby \
   -r "./boot" \
   -r "./configuration" \
   -r "./application" \
diff --git a/bin/local-setup b/bin/local-setup
index 54ba96e..173d339 100755
--- a/bin/local-setup
+++ b/bin/local-setup
@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-system("bin/local-link")
-system("bin/local _base bundle install")
-system("bin/local _base bundle exec rake db:setup")
+exit(1) unless system("bin/local-link-all")
+exit(1) unless system("bin/local base bundle install")
+exit(1) unless system("bin/local base bundle exec rake db:migrate db:reset")
diff --git a/bin/local-typecheck b/bin/local-typecheck
new file mode 100755
index 0000000..49de753
--- /dev/null
+++ b/bin/local-typecheck
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -e
+
+bin/local $1 "bundle exec srb tc"
diff --git a/bin/local-unlink b/bin/local-unlink
deleted file mode 100755
index cb59cd5..0000000
--- a/bin/local-unlink
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-
-File.read("SERVICES").split("\n").each do |name|
-  system("unlink #{name}/db/")
-  system("unlink #{name}/boot.rb")
-  system("unlink #{name}/config.ru")
-  system("unlink #{name}/mocks.rb")
-  system("unlink #{name}/configuration.rb")
-  system("unlink #{name}/application.rb")
-  system("unlink #{name}/database.rb")
-  system("unlink #{name}/Rakefile")
-end
diff --git a/bin/local-unlink-all b/bin/local-unlink-all
new file mode 100755
index 0000000..0558fda
--- /dev/null
+++ b/bin/local-unlink-all
@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+File.read("SERVICES").split("\n").each do |name|
+  puts "Creating links for #{name}/..."
+  exit unless system("unlink #{name}/db/")
+  exit unless system("unlink #{name}/middleware/")
+  exit unless system("unlink #{name}/boot.rb")
+  exit unless system("unlink #{name}/config.ru")
+  exit unless system("unlink #{name}/mocks.rb")
+  exit unless system("unlink #{name}/configuration.rb")
+  exit unless system("unlink #{name}/application.rb")
+  exit unless system("unlink #{name}/database.rb")
+  exit unless system("unlink #{name}/Rakefile")
+end
diff --git a/bin/service-automatic-create b/bin/service-automatic-create
index d8255ae..a0daa41 100755
--- a/bin/service-automatic-create
+++ b/bin/service-automatic-create
@@ -1,14 +1,13 @@
 #!/usr/bin/env ruby
 
-system("bin/local _base ../_services/postgres/docker-entrypoint-initdb.d/create-users-and-groups.sh")
 if File.exist?("DRAFT")
   name = File.read("DRAFT").chomp.gsub(/(\W|\.)/, "-")
-  system("mkdir #{name}/")
-  system("cp -r _template/* #{name}/")
+  exit(1) unless system("mkdir #{name}/")
+  exit(1) unless system("cp -r .template/* #{name}/")
   File.write(File.join(name, "Dockerfile"), File.read(File.join(name, "Dockerfile")).gsub("{{name}}", name))
   File.write("SERVICES", [*File.read("SERVICES").split("\n"), name].join("\n"))
-  system("git add SERVICES #{name}/")
-  system("git rm DRAFT")
-  system("git commit -m 'Finalizing the creation of #{name}'")
-  system("git push origin HEAD")
+  exit(1) unless system("git add SERVICES #{name}/")
+  exit(1) unless system("git rm DRAFT")
+  exit(1) unless system("git commit -m 'Finalizing the creation of #{name}'")
+  exit(1) unless system("git push origin HEAD")
 end
diff --git a/bin/service-manual-create b/bin/service-manual-create
index c1e80d2..d6fddff 100755
--- a/bin/service-manual-create
+++ b/bin/service-manual-create
@@ -2,9 +2,9 @@
 
 puts "What's the name of this function?"
 name = gets.chomp.gsub(/(\W|\.)/, "-")
-system("mkdir #{name}/")
-system("cp -r _template/* #{name}/")
+exit(1) unless system("mkdir #{name}/")
+exit(1) unless system("cp -r .template/* #{name}/")
 File.write(File.join(name, "Dockerfile"), File.read(File.join(name, "Dockerfile")).gsub("{{name}}", name))
 File.write("SERVICES", [**File.read("SERVICES").split("\n"), name].join("\n"))
-system("git add SERVICES #{name}/")
-system("git commit -m 'Finalizing the creation of #{name}'")
+exit(1) unless system("git add SERVICES #{name}/")
+exit(1) unless system("git commit -m 'Finalizing the creation of #{name}'")
diff --git a/docker-compose.yaml b/docker-compose.yaml
index b3e8ff8..79c604b 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -8,8 +8,8 @@ services:
     labels:
       traefik.enable: "false"
     volumes:
-      - "./_services/postgres/data/:/var/lib/postgresql/data/"
-      - "./_services/postgres/docker-entrypoint-initdb.d/:/docker-entrypoint-initdb.d/"
+      - "./.docker-compose/postgres/data/:/var/lib/postgresql/data/"
+      - "./.docker-compose/postgres/docker-entrypoint-initdb.d/:/docker-entrypoint-initdb.d/"
     logging:
       options:
         max-size: 1m
diff --git a/mtgjson-import-cards/function.rb b/mtgjson-import-cards/function.rb
index 2a5ce09..fdf4d68 100644
--- a/mtgjson-import-cards/function.rb
+++ b/mtgjson-import-cards/function.rb
@@ -1,21 +1,21 @@
 # typed: true
-def function(request:, response:, database:)
+def function(request:, database:, logger:)
   uri = URI("https://mtgjson.com/json/AllCards.json")
 
-  LOGGER.info("Fetching cards")
+  logger.info("Fetching cards")
   document = Net::HTTP.get(uri)
 
-  LOGGER.info("Parsing JSON")
+  logger.info("Parsing JSON")
   json = JSON.parse(document)
 
-  LOGGER.info("Getting table")
+  logger.info("Getting table")
   mtgjson_imports = database.relations.fetch("mtgjson_imports")
 
-  LOGGER.info("Storing cards dump")
+  logger.info("Storing cards dump")
   changeset = mtgjson_imports.changeset(:create, :type => "AllCards", :imported_at => Time.now, :raw => json)
   changeset.commit
 
-  LOGGER.info("Finishing")
-  response.write(mtgjson_imports.count.to_s)
-  response.status = :ok
+  logger.info("Finishing")
+
+  [:ok, {}, [mtgjson_imports.count.to_s]]
 end
diff --git a/mtgjson-import-cards/middleware b/mtgjson-import-cards/middleware
new file mode 120000
index 0000000..6a10ea3
--- /dev/null
+++ b/mtgjson-import-cards/middleware
@@ -0,0 +1 @@
+../base/middleware/
\ No newline at end of file
diff --git a/mtgjson-import-keywords/function.rb b/mtgjson-import-keywords/function.rb
index 37bc87a..7c4fa36 100644
--- a/mtgjson-import-keywords/function.rb
+++ b/mtgjson-import-keywords/function.rb
@@ -1,21 +1,21 @@
 # typed: true
-def function(request:, response:, database:)
+def function(request:, database:, logger:)
   uri = URI("https://mtgjson.com/json/Keywords.json")
 
-  LOGGER.info("Fetching keywords")
+  logger.info("Fetching keywords")
   document = Net::HTTP.get(uri)
 
-  LOGGER.info("Parsing JSON")
+  logger.info("Parsing JSON")
   json = JSON.parse(document)
 
-  LOGGER.info("Getting table")
+  logger.info("Getting table")
   mtgjson_imports = database.relations.fetch("mtgjson_imports")
 
-  LOGGER.info("Storing cards dump")
+  logger.info("Storing cards dump")
   changeset = mtgjson_imports.changeset(:create, :type => "Keywords", :imported_at => Time.now, :raw => json)
   changeset.commit
 
-  LOGGER.info("Finishing")
-  response.write(mtgjson_imports.count.to_s)
-  response.status = :ok
+  logger.info("Finishing")
+
+  [:ok, {}, [mtgjson_imports.count.to_s]]
 end
diff --git a/mtgjson-import-keywords/middleware b/mtgjson-import-keywords/middleware
new file mode 120000
index 0000000..6a10ea3
--- /dev/null
+++ b/mtgjson-import-keywords/middleware
@@ -0,0 +1 @@
+../base/middleware/
\ No newline at end of file
diff --git a/mtgjson-import-sets/function.rb b/mtgjson-import-sets/function.rb
index 72f0b5f..3f5638d 100644
--- a/mtgjson-import-sets/function.rb
+++ b/mtgjson-import-sets/function.rb
@@ -1,21 +1,21 @@
 # typed: true
-def function(request:, response:, database:)
+def function(request:, database:, logger:)
   uri = URI("https://mtgjson.com/json/AllSets.json")
 
-  LOGGER.info("Fetching sets")
+  logger.info("Fetching sets")
   document = Net::HTTP.get(uri)
 
-  LOGGER.info("Parsing JSON")
+  logger.info("Parsing JSON")
   json = JSON.parse(document)
 
-  LOGGER.info("Getting table")
+  logger.info("Getting table")
   mtgjson_imports = database.relations.fetch("mtgjson_imports")
 
-  LOGGER.info("Storing cards dump")
+  logger.info("Storing cards dump")
   changeset = mtgjson_imports.changeset(:create, :type => "AllSets", :imported_at => Time.now, :raw => json)
   changeset.commit
 
-  LOGGER.info("Finishing")
-  response.write(mtgjson_imports.count.to_s)
-  response.status = :ok
+  logger.info("Finishing")
+
+  [:ok, {}, [mtgjson_imports.count.to_s]]
 end
diff --git a/mtgjson-import-sets/middleware b/mtgjson-import-sets/middleware
new file mode 120000
index 0000000..6a10ea3
--- /dev/null
+++ b/mtgjson-import-sets/middleware
@@ -0,0 +1 @@
+../base/middleware/
\ No newline at end of file